How could I add an instance of logger to the async context?

[adaboese]

I use a custom logging utility within my codebase. It would be pretty hard to rewrite the entire codebase to interop with Inngest logger. What I would like to do instead is inject the logger into the async context and check inside my logger if that logger is available.

const { AsyncLocalStorage } = require('node:async_hooks');

const myLog = () => {
  const inngestLogger = asyncLocalStorage.getStore();

  if (inngestLogger) {
    // use Inngest logger
  } else {
    // use my own logger
  }
};

I need this logger to be injected at a start of every function execution. What's the best way to do it?

---

I tried writing a middleware, but it does not seem like the logger is available:

export const logMiddleware = new InngestMiddleware({
  init({ client }) {
    return {
      onFunctionRun(args) {
        console.log('onFunctionRun', typeof args.logger);

        return {
          afterExecution() {
            console.log('afterExecution');
          },
          beforeExecution(...args) {
            console.log('beforeExecution', typeof args.logger);
          },
        };
      },
    };
  },
  name: 'Logger ALS Middleware',
});

Produces:

onFunctionRun undefined
beforeExecution undefined

---

In principal this works, just need to figure out how to get a reference to the logger. CC @djfarrelly @IGassmann @jpwilliams

[darwin67]

You should be able to access it using something like.

let providedLogger: Logger = client["logger"];

This is the built-in logger middleware implementation, so you should be able to reference it for what you want it to do.
https://github.com/inngest/inngest-js/blob/a97c0e599f843836380b8defdd1e2ee158059e82/packages/inngest/src/components/Inngest.ts#L606-L664

[jpwilliams]

Regarding using middleware, you can access the function's arguments (and therefore the logger) with the transformInput() hook, e.g.:

export const logMiddleware = new InngestMiddleware({
  init() {
    return {
      onFunctionRun() {
        return {
          transformInput({ ctx }) {
            // `ctx.logger` is the logger
          },
        };
      },
    };
  },
  name: "Logger ALS Middleware",
});

I'd probably then use the afterExecution() hook (as it looks like you're doing) to remove it from your async hooks store.

The likely cause of some confusion is that the logger is, internally, also middleware, so the types for it aren't shown in userland middleware. 🙄 There's an old PR inngest/inngest-js#332 that resolves this. I'll look at pulling that in to make this path a bit more obvious in the future.

[adaboese]

This didn't quite work as I expected that it would.

This is my middleware:

import {
  inngestLoggerStorage,
  type Logger,
} from '#app/asyncLocalStorages/inngestLoggerStorage';
import { InngestMiddleware } from 'inngest';

/**
 * @see https://github.com/orgs/inngest/discussions/989
 */
export const logMiddleware = new InngestMiddleware({
  init() {
    let logger: Logger;

    return {
      onFunctionRun() {
        return {
          afterExecution() {
            inngestLoggerStorage.exit(logger);
          },
          beforeExecution() {
            inngestLoggerStorage.enterWith(logger);
          },
          transformInput({ ctx }) {
            // @ts-expect-error – we know that ctx.logger is a Logger
            logger = ctx.logger.logger.log as Logger;
          },
        };
      },
    };
  },
  name: 'Logger ALS Middleware',
});

and my log function is similar to:

export const log = (message: string, ...args: unknown[]) => {
  const inngestLogger = inngestLoggerStorage.getStore();

  if (inngestLogger) {
    inngestLogger(message, ...args);
  } else {
    console.log('falling back to console.log', message, ...args);
  }
};

This gives output:

before foo
during foo

falling back to console.log before %s foo
falling back to console.log after %s foo

falling back to console.log before %s foo
falling back to console.log during %s foo

Looks like the first part is correct (?). But then logger instance disappears?