autotel-effect 3.0.0 → 4.0.0

package/README.md

@@ -75,7 +75,36 @@ appLayer.pipe(Layer.provideMerge(layer({ serviceName: 'my-api' })));
 
 HTTP spans from autotel's `node:http` instrumentation become parents of domain spans from `Effect.withSpan`.
 
-### 3. Unit tests: provide nothing
+### 3. Logs come with it
+
+One `layer()` call bridges both signals. `Effect.log*` becomes an OpenTelemetry
+**log record** (so it reaches any OTLP log backend, including autotel-devtools)
+plus a trace-correlated structured line on stdout — no second layer to remember:
+
+```typescript
+const AutotelEffect = layer({ serviceName: 'my-api' }); // spans + logs
+```
+
+Pass `logs: false` for spans only, or an options object to configure the
+logger. Log annotations become log metadata, and failure causes are logged as
+`err`:
+
+```typescript
+Effect.log('charged').pipe(Effect.annotateLogs({ 'order.id': 'o-1' }));
+// {"level":"info","msg":"charged","order.id":"o-1","traceId":"...","spanId":"..."}
+```
+
+Errors keep their stack: a `Cause` passed to `Effect.logError` (or an `Error`
+in the message parts) is logged as `err` rather than stringified into `msg`.
+
+Options: `mergeWithExisting: true` keeps Effect's console logger alongside this
+one; `level` sets the stdout minimum level (default `'info'` — leave it there
+and `Effect.logDebug` never reaches stdout even when Effect's own minimum level
+allows it); `pretty: true` swaps JSON for human-readable stdout; `console: false`
+drops the stdout line and emits only the log record — use it when
+`captureConsole()` is on, or every Effect log is reported twice.
+
+### 4. Unit tests: provide nothing
 
 Effect's default `Tracer` is already an in-memory native tracer, so handler tests
 need no layer at all — `Effect.withSpan` runs and exports nowhere:

package/dist/index.cjs

@@ -25,20 +25,99 @@ let _effect_opentelemetry_OtelTracer = require("@effect/opentelemetry/OtelTracer
 _effect_opentelemetry_OtelTracer = __toESM(_effect_opentelemetry_OtelTracer, 1);
 let _effect_opentelemetry_Resource = require("@effect/opentelemetry/Resource");
 _effect_opentelemetry_Resource = __toESM(_effect_opentelemetry_Resource, 1);
+let _opentelemetry_api_logs = require("@opentelemetry/api-logs");
+let autotel_logger = require("autotel/logger");
+let effect_Cause = require("effect/Cause");
+effect_Cause = __toESM(effect_Cause, 1);
 let effect_Layer = require("effect/Layer");
 effect_Layer = __toESM(effect_Layer, 1);
+let effect_Logger = require("effect/Logger");
+effect_Logger = __toESM(effect_Logger, 1);
+let effect_References = require("effect/References");
+effect_References = __toESM(effect_References, 1);
 //#region src/index.ts
 /**
-* Routes `Effect.withSpan` through autotel's global OpenTelemetry provider.
+* Routes `Effect.withSpan` and `Effect.log*` through autotel's global
+* OpenTelemetry provider.
 *
 * Call `autotel.init()` before this layer is built — typically by loading an
 * instrumentation module with `node --import` or `tsx --import`.
 */
 function layer(options) {
-	return _effect_opentelemetry_OtelTracer.layerGlobal.pipe(effect_Layer.provide(_effect_opentelemetry_Resource.layer({
+	const tracer = _effect_opentelemetry_OtelTracer.layerGlobal.pipe(effect_Layer.provide(_effect_opentelemetry_Resource.layer({
 		serviceName: options.serviceName,
 		...options.serviceVersion ? { serviceVersion: options.serviceVersion } : {}
 	})));
+	const logs = options.logs ?? true;
+	return effect_Layer.mergeAll(tracer, logs === false ? effect_Layer.empty : loggerLayer({
+		serviceName: options.serviceName,
+		...options.serviceVersion ? { serviceVersion: options.serviceVersion } : {},
+		...logs === true ? {} : logs
+	}));
+}
+/**
+* Routes Effect's `Effect.log*` through autotel instead of Effect's console
+* logger, emitting each log as an OpenTelemetry log record (so it reaches any
+* OTLP log backend, autotel-devtools included) and, unless disabled, a
+* structured line on stdout via autotel's built-in logger.
+*
+* `layer()` already includes this. Reach for it on its own only when something
+* else owns the tracer and you want autotel to own the logs.
+*/
+function loggerLayer(options) {
+	const log = (0, autotel_logger.createBuiltinLogger)(options.serviceName, {
+		...options.level ? { level: options.level } : {},
+		...options.pretty ? { pretty: options.pretty } : {}
+	});
+	const otelLogger = () => _opentelemetry_api_logs.logs.getLogger(options.serviceName, options.serviceVersion);
+	return effect_Logger.layer([effect_Logger.make(({ cause, fiber, logLevel, message }) => {
+		const method = LEVEL_TO_METHOD[logLevel];
+		if (!method) return;
+		const parts = Array.isArray(message) ? message : [message];
+		const metadata = { ...fiber.getRef(effect_References.CurrentLogAnnotations) };
+		const errors = parts.filter((part) => part instanceof Error);
+		if (cause.reasons.length > 0) metadata.err = effect_Cause.pretty(cause);
+		else if (errors.length > 0) metadata.err = errors.map((error) => error.stack ?? String(error));
+		const body = parts.map(formatPart).join(" ");
+		if (options.console ?? true) log[method](metadata, body);
+		otelLogger().emit({
+			body,
+			severityNumber: LEVEL_TO_SEVERITY[logLevel],
+			severityText: logLevel,
+			attributes: {
+				...metadata,
+				...Array.isArray(metadata.err) ? { err: metadata.err.join("\n") } : {}
+			}
+		});
+	})], { mergeWithExisting: options.mergeWithExisting ?? false });
+}
+const LEVEL_TO_METHOD = {
+	Trace: "debug",
+	Debug: "debug",
+	Info: "info",
+	Warn: "warn",
+	Error: "error",
+	Fatal: "error"
+};
+const LEVEL_TO_SEVERITY = {
+	All: _opentelemetry_api_logs.SeverityNumber.UNSPECIFIED,
+	Trace: _opentelemetry_api_logs.SeverityNumber.TRACE,
+	Debug: _opentelemetry_api_logs.SeverityNumber.DEBUG,
+	Info: _opentelemetry_api_logs.SeverityNumber.INFO,
+	Warn: _opentelemetry_api_logs.SeverityNumber.WARN,
+	Error: _opentelemetry_api_logs.SeverityNumber.ERROR,
+	Fatal: _opentelemetry_api_logs.SeverityNumber.FATAL,
+	None: _opentelemetry_api_logs.SeverityNumber.UNSPECIFIED
+};
+function formatPart(part) {
+	if (typeof part === "string") return part;
+	if (part instanceof Error) return String(part);
+	try {
+		return JSON.stringify(part) ?? String(part);
+	} catch {
+		return String(part);
+	}
 }
 //#endregion
 exports.layer = layer;
+exports.loggerLayer = loggerLayer;

package/dist/index.d.cts

@@ -1,16 +1,50 @@
-import * as OtelTracer from "@effect/opentelemetry/OtelTracer";
+import { BuiltinLoggerOptions } from "autotel/logger";
 import * as Layer from "effect/Layer";
 //#region src/index.d.ts
+interface AutotelEffectLoggerOptions {
+  /** Keep Effect's default console logger alongside this one. Default: false. */
+  readonly mergeWithExisting?: boolean;
+  /**
+   * Minimum level autotel's logger emits to stdout. Default: `'info'` — leave
+   * it there and `Effect.logDebug` never reaches stdout even when Effect's own
+   * minimum log level allows it.
+   */
+  readonly level?: BuiltinLoggerOptions['level'];
+  /** Pretty-print the stdout line instead of JSON. Default: false. */
+  readonly pretty?: boolean;
+  /**
+   * Also write each log to stdout via autotel's built-in logger.
+   * Default: true. Set to false when `captureConsole()` is on, otherwise
+   * every Effect log is reported twice.
+   */
+  readonly console?: boolean;
+}
 interface AutotelEffectLayerOptions {
   readonly serviceName: string;
   readonly serviceVersion?: string;
+  /**
+   * Bridge `Effect.log*` as well as spans. Default: `true`. Pass `false` for
+   * spans only, or an options object to configure the logger.
+   */
+  readonly logs?: boolean | AutotelEffectLoggerOptions;
 }
 /**
- * Routes `Effect.withSpan` through autotel's global OpenTelemetry provider.
+ * Routes `Effect.withSpan` and `Effect.log*` through autotel's global
+ * OpenTelemetry provider.
  *
  * Call `autotel.init()` before this layer is built — typically by loading an
  * instrumentation module with `node --import` or `tsx --import`.
  */
-declare function layer(options: AutotelEffectLayerOptions): Layer.Layer<OtelTracer.OtelTracer, never, never>;
+declare function layer(options: AutotelEffectLayerOptions): Layer.Layer<never>;
+/**
+ * Routes Effect's `Effect.log*` through autotel instead of Effect's console
+ * logger, emitting each log as an OpenTelemetry log record (so it reaches any
+ * OTLP log backend, autotel-devtools included) and, unless disabled, a
+ * structured line on stdout via autotel's built-in logger.
+ *
+ * `layer()` already includes this. Reach for it on its own only when something
+ * else owns the tracer and you want autotel to own the logs.
+ */
+declare function loggerLayer(options: Omit<AutotelEffectLayerOptions, 'logs'> & AutotelEffectLoggerOptions): Layer.Layer<never, never, never>;
 //#endregion
-export { AutotelEffectLayerOptions, layer };
+export { AutotelEffectLayerOptions, AutotelEffectLoggerOptions, layer, loggerLayer };

package/dist/index.d.ts

@@ -1,16 +1,50 @@
-import * as OtelTracer from "@effect/opentelemetry/OtelTracer";
+import { BuiltinLoggerOptions } from "autotel/logger";
 import * as Layer from "effect/Layer";
 //#region src/index.d.ts
+interface AutotelEffectLoggerOptions {
+  /** Keep Effect's default console logger alongside this one. Default: false. */
+  readonly mergeWithExisting?: boolean;
+  /**
+   * Minimum level autotel's logger emits to stdout. Default: `'info'` — leave
+   * it there and `Effect.logDebug` never reaches stdout even when Effect's own
+   * minimum log level allows it.
+   */
+  readonly level?: BuiltinLoggerOptions['level'];
+  /** Pretty-print the stdout line instead of JSON. Default: false. */
+  readonly pretty?: boolean;
+  /**
+   * Also write each log to stdout via autotel's built-in logger.
+   * Default: true. Set to false when `captureConsole()` is on, otherwise
+   * every Effect log is reported twice.
+   */
+  readonly console?: boolean;
+}
 interface AutotelEffectLayerOptions {
   readonly serviceName: string;
   readonly serviceVersion?: string;
+  /**
+   * Bridge `Effect.log*` as well as spans. Default: `true`. Pass `false` for
+   * spans only, or an options object to configure the logger.
+   */
+  readonly logs?: boolean | AutotelEffectLoggerOptions;
 }
 /**
- * Routes `Effect.withSpan` through autotel's global OpenTelemetry provider.
+ * Routes `Effect.withSpan` and `Effect.log*` through autotel's global
+ * OpenTelemetry provider.
  *
  * Call `autotel.init()` before this layer is built — typically by loading an
  * instrumentation module with `node --import` or `tsx --import`.
  */
-declare function layer(options: AutotelEffectLayerOptions): Layer.Layer<OtelTracer.OtelTracer, never, never>;
+declare function layer(options: AutotelEffectLayerOptions): Layer.Layer<never>;
+/**
+ * Routes Effect's `Effect.log*` through autotel instead of Effect's console
+ * logger, emitting each log as an OpenTelemetry log record (so it reaches any
+ * OTLP log backend, autotel-devtools included) and, unless disabled, a
+ * structured line on stdout via autotel's built-in logger.
+ *
+ * `layer()` already includes this. Reach for it on its own only when something
+ * else owns the tracer and you want autotel to own the logs.
+ */
+declare function loggerLayer(options: Omit<AutotelEffectLayerOptions, 'logs'> & AutotelEffectLoggerOptions): Layer.Layer<never, never, never>;
 //#endregion
-export { AutotelEffectLayerOptions, layer };
+export { AutotelEffectLayerOptions, AutotelEffectLoggerOptions, layer, loggerLayer };

package/dist/index.js

@@ -1,18 +1,93 @@
 import * as OtelTracer from "@effect/opentelemetry/OtelTracer";
 import * as Resource from "@effect/opentelemetry/Resource";
+import { SeverityNumber, logs } from "@opentelemetry/api-logs";
+import { createBuiltinLogger } from "autotel/logger";
+import * as Cause from "effect/Cause";
 import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as References from "effect/References";
 //#region src/index.ts
 /**
-* Routes `Effect.withSpan` through autotel's global OpenTelemetry provider.
+* Routes `Effect.withSpan` and `Effect.log*` through autotel's global
+* OpenTelemetry provider.
 *
 * Call `autotel.init()` before this layer is built — typically by loading an
 * instrumentation module with `node --import` or `tsx --import`.
 */
 function layer(options) {
-	return OtelTracer.layerGlobal.pipe(Layer.provide(Resource.layer({
+	const tracer = OtelTracer.layerGlobal.pipe(Layer.provide(Resource.layer({
 		serviceName: options.serviceName,
 		...options.serviceVersion ? { serviceVersion: options.serviceVersion } : {}
 	})));
+	const logs = options.logs ?? true;
+	return Layer.mergeAll(tracer, logs === false ? Layer.empty : loggerLayer({
+		serviceName: options.serviceName,
+		...options.serviceVersion ? { serviceVersion: options.serviceVersion } : {},
+		...logs === true ? {} : logs
+	}));
+}
+/**
+* Routes Effect's `Effect.log*` through autotel instead of Effect's console
+* logger, emitting each log as an OpenTelemetry log record (so it reaches any
+* OTLP log backend, autotel-devtools included) and, unless disabled, a
+* structured line on stdout via autotel's built-in logger.
+*
+* `layer()` already includes this. Reach for it on its own only when something
+* else owns the tracer and you want autotel to own the logs.
+*/
+function loggerLayer(options) {
+	const log = createBuiltinLogger(options.serviceName, {
+		...options.level ? { level: options.level } : {},
+		...options.pretty ? { pretty: options.pretty } : {}
+	});
+	const otelLogger = () => logs.getLogger(options.serviceName, options.serviceVersion);
+	return Logger.layer([Logger.make(({ cause, fiber, logLevel, message }) => {
+		const method = LEVEL_TO_METHOD[logLevel];
+		if (!method) return;
+		const parts = Array.isArray(message) ? message : [message];
+		const metadata = { ...fiber.getRef(References.CurrentLogAnnotations) };
+		const errors = parts.filter((part) => part instanceof Error);
+		if (cause.reasons.length > 0) metadata.err = Cause.pretty(cause);
+		else if (errors.length > 0) metadata.err = errors.map((error) => error.stack ?? String(error));
+		const body = parts.map(formatPart).join(" ");
+		if (options.console ?? true) log[method](metadata, body);
+		otelLogger().emit({
+			body,
+			severityNumber: LEVEL_TO_SEVERITY[logLevel],
+			severityText: logLevel,
+			attributes: {
+				...metadata,
+				...Array.isArray(metadata.err) ? { err: metadata.err.join("\n") } : {}
+			}
+		});
+	})], { mergeWithExisting: options.mergeWithExisting ?? false });
+}
+const LEVEL_TO_METHOD = {
+	Trace: "debug",
+	Debug: "debug",
+	Info: "info",
+	Warn: "warn",
+	Error: "error",
+	Fatal: "error"
+};
+const LEVEL_TO_SEVERITY = {
+	All: SeverityNumber.UNSPECIFIED,
+	Trace: SeverityNumber.TRACE,
+	Debug: SeverityNumber.DEBUG,
+	Info: SeverityNumber.INFO,
+	Warn: SeverityNumber.WARN,
+	Error: SeverityNumber.ERROR,
+	Fatal: SeverityNumber.FATAL,
+	None: SeverityNumber.UNSPECIFIED
+};
+function formatPart(part) {
+	if (typeof part === "string") return part;
+	if (part instanceof Error) return String(part);
+	try {
+		return JSON.stringify(part) ?? String(part);
+	} catch {
+		return String(part);
+	}
 }
 //#endregion
-export { layer };
+export { layer, loggerLayer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autotel-effect",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "description": "Bridge autotel and Effect v4: Effect.withSpan spans export through autotel's global TracerProvider",
   "type": "module",
   "main": "./dist/index.js",
@@ -50,14 +50,19 @@
   },
   "devDependencies": {
     "@effect/opentelemetry": "4.0.0-rc.112",
+    "@opentelemetry/api-logs": "^0.222.0",
+    "@opentelemetry/sdk-logs": "^0.222.0",
     "@types/node": "^26.1.2",
-    "autotel": "7.6.0",
+    "autotel": "7.6.1",
     "effect": "4.0.0-rc.112",
     "rimraf": "^6.1.3",
     "tsdown": "^0.22.14",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10"
   },
+  "dependencies": {
+    "@opentelemetry/api-logs": "^0.222.0"
+  },
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",