LogTape 1.3.0: Framework integrations and SDK-friendly logging

[dahlia]

LogTape is a logging library for JavaScript and TypeScript that works across Deno, Node.js, Bun, and browsers. It's built around structured logging with zero dependencies and flexible configuration.

Version 1.3.0 is our biggest release yet, bringing first-class integrations for the most popular web frameworks and a powerful new feature for SDK authors. Here's what's new.

Category prefix for library authors

If you've ever built an SDK that wraps other libraries, you've probably run into this problem: logs from your internal dependencies show up with their category names, not yours. Application developers configuring logging for your SDK have no idea they also need to configure every internal library you happen to use.

The new withCategoryPrefix() function solves this by prepending your SDK's category to all log records within a callback context:

import { getLogger, withCategoryPrefix } from "@logtape/logtape";
import { internalDatabaseLib } from "some-internal-lib";

export class MySDK {
  private logger = getLogger(["my-sdk"]);

  async query(sql: string) {
    return withCategoryPrefix(["my-sdk"], () => {
      this.logger.debug("Starting query", { sql });
      // If internalDatabaseLib logs with ["internal-db"], 
      // it now appears as ["my-sdk", "internal-db"]
      return internalDatabaseLib.query(sql);
    });
  }
}

Now application developers can configure logging for ["my-sdk"] and automatically capture all internal logs without knowing anything about your implementation details. Prefixes accumulate when nested, so multi-layer architectures work naturally.

This feature uses the same contextLocalStorage configuration as implicit contexts, so if you're already using withContext(), no additional setup is required. See the category prefix documentation for more details.

Web framework integrations

LogTape now provides official middleware packages for the four most popular Node.js web frameworks. Each offers Morgan-compatible format presets, custom format functions, structured logging output, and request filtering.

Express

The @logtape/express package provides HTTP request logging as a drop-in replacement for Morgan:

import { expressLogger } from "@logtape/express";
import express from "express";

const app = express();
app.use(expressLogger());  // Uses "combined" format by default

// Or with options
app.use(expressLogger({
  format: "dev",
  skip: (req, res) => res.statusCode < 400,
}));

Fastify

The @logtape/fastify package provides a Pino-compatible logger that integrates with Fastify's built-in logging system:

import { getLogTapeFastifyLogger } from "@logtape/fastify";
import Fastify from "fastify";

const fastify = Fastify({
  loggerInstance: getLogTapeFastifyLogger(),
});

fastify.get("/users/:id", async (request) => {
  request.log.info({ userId: request.params }, "Fetching user");
  return { user: "data" };
});

The adapter supports all Pino method signatures including printf-style interpolation (%s, %d, %j, %o), and child() bindings map to LogTape's Logger.with().

Hono

The @logtape/hono package works across all of Hono's supported runtimes—Cloudflare Workers, Deno, Bun, and Node.js:

import { Hono } from "hono";
import { honoLogger } from "@logtape/hono";

const app = new Hono();
app.use(honoLogger());

export default app;

Koa

The @logtape/koa package provides middleware for Koa applications:

import { koaLogger } from "@logtape/koa";
import Koa from "koa";

const app = new Koa();
app.use(koaLogger());

All four packages share a consistent API: predefined formats (combined, common, dev, short, tiny), custom format functions, skip for filtering, and structured logging output with fields like method, url, status, responseTime, userAgent, and more.

See the framework integration documentation for complete details.

Drizzle ORM integration

The new @logtape/drizzle-orm package lets you use LogTape as Drizzle's logging backend:

import { getLogger } from "@logtape/drizzle-orm";
import { drizzle } from "drizzle-orm/postgres-js";
import postgres from "postgres";

const client = postgres(process.env.DATABASE_URL!);
const db = drizzle(client, { logger: getLogger() });

Each query is logged with structured data: formattedQuery (with parameter values substituted for readability), query (original parameterized string), and params (original array). This gives you human-readable output with text formatters while preserving full query data for OpenTelemetry, Sentry, or JSON Lines sinks.

OpenTelemetry protocol expansion

The @logtape/otel package now supports all three OTLP protocols:

• http/json: HTTP with JSON encoding (default, works everywhere including browsers)
• http/protobuf: HTTP with Protocol Buffers encoding (more efficient)
• grpc: gRPC protocol (most efficient for high-volume logging, Node.js/Deno/Bun only)

Protocol selection follows the OpenTelemetry specification via environment variables (OTEL_EXPORTER_OTLP_LOGS_PROTOCOL or OTEL_EXPORTER_OTLP_PROTOCOL). The gRPC exporter is dynamically imported only when needed, so browser bundles stay lean.

A new additionalResource option lets you add custom resource attributes without providing a full custom LoggerProvider:

import { getOpenTelemetrySink } from "@logtape/otel";
import { resourceFromAttributes } from "@opentelemetry/resources";
import { SEMRESATTRS_DEPLOYMENT_ENVIRONMENT } from "@opentelemetry/semantic-conventions";

getOpenTelemetrySink({
  serviceName: "my-service",
  additionalResource: resourceFromAttributes({
    [SEMRESATTRS_DEPLOYMENT_ENVIRONMENT]: "production",
  }),
});

Enhanced Sentry integration

The @logtape/sentry package now offers deeper integration with Sentry's observability features:

• Automatic trace correlation: Logs automatically include trace_id and span_id from active Sentry spans with zero configuration.
• Breadcrumbs: Enable enableBreadcrumbs: true to create a debugging context trail.
• Structured logging: When using Sentry SDK 9.41.0+ with enableLogs: true, the sink automatically uses Sentry's Logs API.
• Filtering: A new beforeSend hook lets you transform or filter log records.

Security improvements

This release includes important security fixes in @logtape/redaction: infinite loops when processing circular references, and missing redaction of sensitive data in class instances.

The @logtape/syslog package now supports TLS for TCP connections via the new secure and tlsOptions options.

Upgrading

LogTape 1.3.0 is fully backward compatible with 1.2.x. Just update your packages:

npm update @logtape/logtape
# or
deno add jsr:@logtape/logtape@^1.3.0

For the new integrations:

npm install @logtape/express @logtape/fastify @logtape/hono @logtape/koa @logtape/drizzle-orm
# or
deno add --jsr @logtape/express @logtape/fastify @logtape/hono @logtape/koa @logtape/drizzle-orm

All satellite packages share the same version number with the core package for easy dependency management. See the full changelog for complete details.