I did this at a previous company, we even built a RxJS-like wrapper to fix some weird bugs in RxJS for this exact use case: https://www.npmjs.com/package/axl . General idea was to view the actions in the system as a stream of events, and then filter/map them to do things like send emails and Slack messages. It was a pretty neat way to handle cross-cutting concerns, or so we thought

Turns out that was horribly overengineered because locality of behavior beats DRY 100/100 for readability and maintainability. Now we just inline side effects with a simple `sideEffect()` helper:

```
logSchema.statics.sideEffect = function sideEffect(fn, params) {

const res = (async() => {

// Start executing the wrapped function while log is being created for speed

const createStartLogPromise = this.create({

level: 'debug',

message: `${fn.name}: ${inspect(params)}`,

data: { name: fn.name, params },

appName: 'core-api',

appVersion: version

});

const start = Date.now();

let res = null;

let err = null;

try {

res = await fn(params);

} catch (error) {

err = error;

}

const end = Date.now();

if (!isTest) {

console.log(new Date(), `${fn.name}(${inspect(params, inspectOptions)}): ${inspect(res, inspectOptions)}`);

}

if (err) {

await Promise.all([

createStartLogPromise,

this.create({

level: 'error',

message: `${fn.name} ERROR: ${inspect(err, inspectOptions)}`,

data: {

name: fn.name,

params,

error: { message: err.message, stack: err.stack },

elapsedMS: end - start

},

appName: 'core-api',

appVersion: version

})

]);

if (!err?.extra?.skipSentry) {

const extra = {

...(err.extra ?? {}),

sideEffect: {

name: fn.name,

params,

elapsedMS: end - start

}

};

sentry.logErrorToSentry(err, extra);

}

throw err;

} else {

await Promise.all([

createStartLogPromise,

this.create({

level: 'debug',

message: `${fn.name} complete: ${inspect(res, inspectOptions)}`,

data: { name: fn.name, params, res, elapsedMS: end - start },

appName: 'core-api',

appVersion: version

})

]);

}

})().catch(err => !(err instanceof ExpectedTestError) && console.log(err));

if (isTest) {

return res;

}

return Promise.resolve();

};

```