kth / skog

Logging with context for Node.js

Add context to your Node.js logs

Forest photo by Gustav Gullstrand on Unsplash

Getting started

Skog is a opinionated logging library built on top of Pino.

npm install skog

import log, { initializeLogger } from "skog";

initializeLogger();
setFields({ app: "my-app" });
log.info("Hello world");

If your app uses Express, use skogMiddleware to add req_id to every log line.

import log, { initializeLogger, skogMiddleware, setFields } from "skog";
import express from "express";

const app = express();

const app = express();
app.use(skogMiddleware);
app.get("/", () => {
  // This will log "req_id" automatically! You don't need to do anything else!
  log.info("Logging a message");
});

initializeLogger();
setFields({ app: "demo" });
app.listen(3000, () => {
  log.info("Starting server");
});

Recipes

skog exports more functions so you can create your own middleware. For example, if you want to add your own fields or if you want to create middleware for other frameworks.

Add other fields

Example: add a "session_id" field in your logs

import { runWithSkog } from "skog";
import { nanoid } from "nanoid";

function myMiddleware(req, res, next) {
  // Assuming that "req.session.id" exists...
  runWithSkog({ req_id: nanoid(), session_id: req.session.id.slice(-3) }, next);
}

Middleware for other frameworks

As you can see from the example above, runWithSkog accepts two arguments: an object with fields and a function. runWithSkog will return the same thing as returned by the function.

So, you can create a middleware for Next.js:

import { NextResponse } from "next/server";
import { nanoid } from "nanoid";

function middleware(req: NextRequest, ev: NextFetchEvent) {
  return runWithSkogContext(
    {
      session_id: req.cookies["session_id"]?.slice(-3),
      req_id: nanoid(),
    },
    NextResponse.next
  );
}

skog's Issues

Potentially silently ignoring log lines

I noticed two things in these code lines

skog/packages/skog/src/index.ts

Lines 23 to 27 in a98ba52

	if (typeof arg1 === "string") {
	fn(arg1);
	} else if (typeof arg2 === "undefined" || typeof arg2 === "string") {
	fn(arg1, arg2);
	}

I see two different problems with this code:

1. There is no "fallback else" statement. If this function is called with something else then (string, undefined) or (any, undefined|string) it will be silently ignored. Silently ignoring log lines shouldn't be possible IMO, I would much prefer if it threw an error if this is unexpected usage
2. The code is a bit confusing: if arg2 is undefined, the function call will be fn(arg1, undefined), which is exactly the same as fn(arg1). And if these two calls are identical, what's the purpose of these two "if" blocks? Is this on purpose?