Module 7: Manual Logs

Node.js / Express

The app already uses pino, in src/log.js:

const pino = require('pino');

const log = pino({ level: process.env.LOG_LEVEL ?? 'info' });

module.exports = { log };

There is nothing to install: @opentelemetry/instrumentation-pino is part of the auto-instrumentations bundle you added in Module 4, which is why those log lines have been reaching VictoriaLogs since then. What’s missing is structure.

Today the handlers call it like this — a message with the data melted into it:

log.info('todo created ' + todo.id);

Change them to pass an attribute object first and a constant message second:

log.info({ list: todo.list, todo_id: todo.id }, 'todo created');

Python / Flask

The app already has a logger, in todo_api/log.py:

import logging
import os

LEVEL = os.environ.get("LOG_LEVEL", "INFO").upper()

logging.basicConfig(level=LEVEL)

# Set the level on our own logger rather than relying on the root logger's.
# Under `opentelemetry-instrument` the root logger is configured before the
# application imports anything, which makes a later basicConfig() a no-op.
log = logging.getLogger("todo-api")
log.setLevel(LEVEL)

There is nothing to install: with OTEL_PYTHON_LOG_AUTO_INSTRUMENTATION=true from Module 4, the logging instrumentation attached its handler to the root logger, which is why those log lines have been reaching VictoriaLogs since then. What’s missing is structure.

📌 That comment about the root logger is not decoration. If you configure logging yourself before reading it, your INFO records vanish silently. It is the single most common way a Python service ends up with no logs in the backend and no error anywhere.

Today the handlers call it like this — a message with the data melted into it:

log.info("todo created %s", todo.id)

Change them to put the variable data in extra and keep the message constant:

log.info("todo created", extra={"list": todo.list, "todo_id": str(todo.id)})

Go / net/http

The app logs with slog, in log.go:

var log = slog.New(slog.NewJSONHandler(os.Stdout, nil))

That handler only writes JSON lines to the container’s output, which is why nothing from your API has reached VictoriaLogs yet: otelc adds the trace ID to each record, but it doesn’t send logs anywhere. Send the same records to OpenTelemetry too, with the otelslog bridge — one handler for the terminal, one for OpenTelemetry:

import (
	"log/slog"
	"os"

	"go.opentelemetry.io/contrib/bridges/otelslog"
)

var log = slog.New(slog.NewMultiHandler(
	slog.NewJSONHandler(os.Stdout, nil),
	otelslog.NewHandler("todo-api"),
))

The bridge hands every record to the logger provider that otelc set up in Module 4. What’s missing now is structure.

Today the handlers call it like this — a message with the data melted into it:

log.Info("todo created " + todo.ID)

Change them to pass the request’s context, a constant message, and the data as key-value pairs:

log.InfoContext(ctx, "todo created", "list", todo.List, "todo_id", todo.ID)

The Context variant is not optional: the bridge takes the trace ID from the span in ctx. Log without it and the record arrives with no trace ID at all.

Node.js / Express

todosRouter.post('/todos', async (req, res) => {
  try {
    const todo = await createTodo(req.body);
    // ... the rest of the handler, unchanged, inside the try
  } catch (err) {
    log.error({
      err,                                  // pino serialises type, message, stack
      list: req.body?.list,
      title_length: req.body?.title?.length ?? 0,
    }, 'create todo failed');
    res.status(500).json({ error: 'internal' });
  }
});

Python / Flask

@bp.post("/todos")
def post_todo():
    payload = request.get_json(silent=True) or {}
    try:
        todo = create_todo(payload)
        # ... the rest of the handler, unchanged, inside the try
    except Exception:
        log.exception("create todo failed", extra={       # exception() captures the stack
            "list": payload.get("list"),
            "title_length": len(payload.get("title") or ""),
        })
        return jsonify(error="internal"), 500

Go / net/http

Give the handler one place to report a failure from, and use it on every error path:

func postTodo(w http.ResponseWriter, r *http.Request) error {
	ctx := r.Context()
	body, _ := io.ReadAll(r.Body)

	var in struct {
		Title string `json:"title"`
		List  string `json:"list"`
	}
	_ = json.Unmarshal(body, &in)
	fail := func(err error) error {
		log.ErrorContext(ctx, "create todo failed",
			"err", err,
			"list", in.List,
			"title_length", len(in.Title),
		)
		return err                                    // still answered with a 500
	}

	todo, err := createTodo(ctx, body)
	if err != nil {
		return fail(err)
	}
	// ... the rest of the handler, with every `return err` turned into `return fail(err)`
}

service.name:todo-api AND severity_text:ERROR

service.name:todo-api AND _msg:"todo created" | fields _time, trace_id, list, todo_id

service.name:todo-api AND _time:5m AND list:* | stats by (list) count()

trace_id:=<paste it here>