@piramesse/otel 1.0.0

package/dist/nest/otel-logger.service.js

@@ -0,0 +1,32 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtelLoggerService = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const logger_1 = require("../core/logger");
+/**
+ * NestJS injectable wrapper for OtelLogger
+ */
+let OtelLoggerService = class OtelLoggerService extends logger_1.OtelLogger {
+    constructor(config) {
+        super({
+            endpoint: config.get('OTEL_EXPORTER_OTLP_ENDPOINT', ''),
+            serviceName: config.get('OTEL_SERVICE_NAME', 'unknown-service'),
+        });
+    }
+};
+exports.OtelLoggerService = OtelLoggerService;
+exports.OtelLoggerService = OtelLoggerService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService])
+], OtelLoggerService);
+//# sourceMappingURL=otel-logger.service.js.map

package/dist/nest/otel-logger.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel-logger.service.js","sourceRoot":"","sources":["../../src/nest/otel-logger.service.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2CAA4C;AAC5C,2CAA+C;AAC/C,2CAA4C;AAE5C;;GAEG;AAEI,IAAM,iBAAiB,GAAvB,MAAM,iBAAkB,SAAQ,mBAAU;IAC/C,YAAY,MAAqB;QAC/B,KAAK,CAAC;YACJ,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,6BAA6B,EAAE,EAAE,CAAC;YACvD,WAAW,EAAE,MAAM,CAAC,GAAG,CAAC,mBAAmB,EAAE,iBAAiB,CAAC;SAChE,CAAC,CAAC;IACL,CAAC;CACF,CAAA;AAPY,8CAAiB;4BAAjB,iBAAiB;IAD7B,IAAA,mBAAU,GAAE;qCAES,sBAAa;GADtB,iBAAiB,CAO7B"}

package/dist/nest/otel-tracer.service.d.ts

@@ -0,0 +1,10 @@
+import { ConfigService } from '@nestjs/config';
+import { OtelTracer } from '../core/tracer';
+import { OtelLoggerService } from './otel-logger.service';
+/**
+ * NestJS injectable wrapper for OtelTracer
+ */
+export declare class OtelTracerService extends OtelTracer {
+    constructor(config: ConfigService, logger: OtelLoggerService);
+}
+//# sourceMappingURL=otel-tracer.service.d.ts.map

package/dist/nest/otel-tracer.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel-tracer.service.d.ts","sourceRoot":"","sources":["../../src/nest/otel-tracer.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D;;GAEG;AACH,qBACa,iBAAkB,SAAQ,UAAU;gBACnC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,iBAAiB;CAS7D"}

package/dist/nest/otel-tracer.service.js

@@ -0,0 +1,33 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtelTracerService = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const tracer_1 = require("../core/tracer");
+const otel_logger_service_1 = require("./otel-logger.service");
+/**
+ * NestJS injectable wrapper for OtelTracer
+ */
+let OtelTracerService = class OtelTracerService extends tracer_1.OtelTracer {
+    constructor(config, logger) {
+        super({
+            endpoint: config.get('OTEL_EXPORTER_OTLP_ENDPOINT', ''),
+            serviceName: config.get('OTEL_SERVICE_NAME', 'unknown-service'),
+        }, logger);
+    }
+};
+exports.OtelTracerService = OtelTracerService;
+exports.OtelTracerService = OtelTracerService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService, otel_logger_service_1.OtelLoggerService])
+], OtelTracerService);
+//# sourceMappingURL=otel-tracer.service.js.map

package/dist/nest/otel-tracer.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel-tracer.service.js","sourceRoot":"","sources":["../../src/nest/otel-tracer.service.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2CAA4C;AAC5C,2CAA+C;AAC/C,2CAA4C;AAC5C,+DAA0D;AAE1D;;GAEG;AAEI,IAAM,iBAAiB,GAAvB,MAAM,iBAAkB,SAAQ,mBAAU;IAC/C,YAAY,MAAqB,EAAE,MAAyB;QAC1D,KAAK,CACH;YACE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,6BAA6B,EAAE,EAAE,CAAC;YACvD,WAAW,EAAE,MAAM,CAAC,GAAG,CAAC,mBAAmB,EAAE,iBAAiB,CAAC;SAChE,EACD,MAAM,CACP,CAAC;IACJ,CAAC;CACF,CAAA;AAVY,8CAAiB;4BAAjB,iBAAiB;IAD7B,IAAA,mBAAU,GAAE;qCAES,sBAAa,EAAU,uCAAiB;GADjD,iBAAiB,CAU7B"}

package/dist/nest/otel.module.d.ts

@@ -0,0 +1,3 @@
+export declare class OtelModule {
+}
+//# sourceMappingURL=otel.module.d.ts.map

package/dist/nest/otel.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel.module.d.ts","sourceRoot":"","sources":["../../src/nest/otel.module.ts"],"names":[],"mappings":"AAIA,qBAKa,UAAU;CAAG"}

package/dist/nest/otel.module.js

@@ -0,0 +1,23 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtelModule = void 0;
+const common_1 = require("@nestjs/common");
+const otel_logger_service_1 = require("./otel-logger.service");
+const otel_tracer_service_1 = require("./otel-tracer.service");
+let OtelModule = class OtelModule {
+};
+exports.OtelModule = OtelModule;
+exports.OtelModule = OtelModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        providers: [otel_logger_service_1.OtelLoggerService, otel_tracer_service_1.OtelTracerService],
+        exports: [otel_logger_service_1.OtelLoggerService, otel_tracer_service_1.OtelTracerService],
+    })
+], OtelModule);
+//# sourceMappingURL=otel.module.js.map

package/dist/nest/otel.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel.module.js","sourceRoot":"","sources":["../../src/nest/otel.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAgD;AAChD,+DAA0D;AAC1D,+DAA0D;AAOnD,IAAM,UAAU,GAAhB,MAAM,UAAU;CAAG,CAAA;AAAb,gCAAU;qBAAV,UAAU;IALtB,IAAA,eAAM,GAAE;IACR,IAAA,eAAM,EAAC;QACN,SAAS,EAAE,CAAC,uCAAiB,EAAE,uCAAiB,CAAC;QACjD,OAAO,EAAE,CAAC,uCAAiB,EAAE,uCAAiB,CAAC;KAChD,CAAC;GACW,UAAU,CAAG"}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@piramesse/otel",
+  "version": "1.0.0",
+  "description": "OpenTelemetry logging and tracing for NestJS services",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/config": "^3.0.0 || ^4.0.0"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^11.0.20",
+    "@nestjs/config": "^4.0.2",
+    "@types/node": "^25.2.0",
+    "typescript": "^5.7.3"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  }
+}

package/src/core/index.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './logger';
+export * from './tracer';

package/src/core/logger.ts

@@ -0,0 +1,241 @@
+import {
+  OtelConfig,
+  LogData,
+  ScopedLogger,
+  TracedLogger,
+  ComponentLogger,
+} from './types';
+
+export class OtelLogger {
+  private readonly collectorUrl: string;
+  private readonly serviceName: string;
+
+  constructor(config: OtelConfig) {
+    this.collectorUrl = config.endpoint ? `${config.endpoint}/v1/logs` : '';
+    this.serviceName = config.serviceName || 'unknown-service';
+  }
+
+  private getSeverityNumber(level: string): number {
+    const severityMap: Record<string, number> = {
+      debug: 5,
+      info: 9,
+      warn: 13,
+      error: 17,
+    };
+    return severityMap[level] || 9;
+  }
+
+  private convertAttributes(
+    attrs: Record<string, any>,
+  ): Array<{ key: string; value: { stringValue: string } }> {
+    return Object.entries(attrs).map(([key, value]) => ({
+      key,
+      value: { stringValue: String(value) },
+    }));
+  }
+
+  private async sendLogToCollector(data: LogData): Promise<void> {
+    if (!this.collectorUrl) return;
+
+    const allAttributes = {
+      ...(data.component ? { component: data.component } : {}),
+      ...data.attributes,
+    };
+
+    const payload = {
+      resourceLogs: [
+        {
+          resource: {
+            attributes: [
+              { key: 'service.name', value: { stringValue: this.serviceName } },
+            ],
+          },
+          scopeLogs: [
+            {
+              scope: {
+                name: data.component || 'app-logger',
+                version: '1.0.0',
+              },
+              logRecords: [
+                {
+                  timeUnixNano: String(Date.now() * 1000000),
+                  observedTimeUnixNano: String(Date.now() * 1000000),
+                  severityNumber: this.getSeverityNumber(data.level),
+                  severityText: data.level.toUpperCase(),
+                  body: { stringValue: data.message },
+                  attributes: this.convertAttributes(allAttributes),
+                  ...(data.traceId && data.spanId
+                    ? { traceId: data.traceId, spanId: data.spanId, flags: 1 }
+                    : {}),
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    };
+
+    try {
+      await fetch(this.collectorUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+    } catch {
+      // Silently fail
+    }
+  }
+
+  info(msg: string, attrs?: Record<string, any>): void {
+    void this.sendLogToCollector({
+      message: msg,
+      level: 'info',
+      attributes: attrs,
+    });
+  }
+
+  warn(msg: string, attrs?: Record<string, any>): void {
+    void this.sendLogToCollector({
+      message: msg,
+      level: 'warn',
+      attributes: attrs,
+    });
+  }
+
+  error(
+    msg: string,
+    error?: Error | Record<string, any>,
+    attrs?: Record<string, any>,
+  ): void {
+    const errorAttrs =
+      error instanceof Error
+        ? { error: error.message, stack: error.stack, ...attrs }
+        : { ...error, ...attrs };
+
+    void this.sendLogToCollector({
+      message: msg,
+      level: 'error',
+      attributes: errorAttrs,
+    });
+  }
+
+  debug(msg: string, attrs?: Record<string, any>): void {
+    void this.sendLogToCollector({
+      message: msg,
+      level: 'debug',
+      attributes: attrs,
+    });
+  }
+
+  withTrace(traceId: string, spanId: string, component?: string): ScopedLogger {
+    return {
+      info: (msg: string, attrs?: Record<string, any>) => {
+        void this.sendLogToCollector({
+          message: msg,
+          level: 'info',
+          attributes: attrs,
+          traceId,
+          spanId,
+          component,
+        });
+      },
+      warn: (msg: string, attrs?: Record<string, any>) => {
+        void this.sendLogToCollector({
+          message: msg,
+          level: 'warn',
+          attributes: attrs,
+          traceId,
+          spanId,
+          component,
+        });
+      },
+      error: (
+        msg: string,
+        error?: Error | Record<string, any>,
+        attrs?: Record<string, any>,
+      ) => {
+        const errorAttrs =
+          error instanceof Error
+            ? { error: error.message, stack: error.stack, ...attrs }
+            : { ...error, ...attrs };
+
+        void this.sendLogToCollector({
+          message: msg,
+          level: 'error',
+          attributes: errorAttrs,
+          traceId,
+          spanId,
+          component,
+        });
+      },
+      debug: (msg: string, attrs?: Record<string, any>) => {
+        void this.sendLogToCollector({
+          message: msg,
+          level: 'debug',
+          attributes: attrs,
+          traceId,
+          spanId,
+          component,
+        });
+      },
+    };
+  }
+
+  /**
+   * Create a scoped logger for a specific component
+   */
+  forComponent(component: string): ComponentLogger {
+    return {
+      info: (msg: string, attrs?: Record<string, any>) => {
+        void this.sendLogToCollector({
+          message: msg,
+          level: 'info',
+          attributes: attrs,
+          component,
+        });
+      },
+      warn: (msg: string, attrs?: Record<string, any>) => {
+        void this.sendLogToCollector({
+          message: msg,
+          level: 'warn',
+          attributes: attrs,
+          component,
+        });
+      },
+      error: (
+        msg: string,
+        error?: Error | Record<string, any>,
+        attrs?: Record<string, any>,
+      ) => {
+        const errorAttrs =
+          error instanceof Error
+            ? { error: error.message, stack: error.stack, ...attrs }
+            : { ...error, ...attrs };
+
+        void this.sendLogToCollector({
+          message: msg,
+          level: 'error',
+          attributes: errorAttrs,
+          component,
+        });
+      },
+      debug: (msg: string, attrs?: Record<string, any>) => {
+        void this.sendLogToCollector({
+          message: msg,
+          level: 'debug',
+          attributes: attrs,
+          component,
+        });
+      },
+      withTrace: (traceId: string, spanId: string) =>
+        this.withTrace(traceId, spanId, component),
+    };
+  }
+}
+
+/**
+ * Factory function to create a logger instance
+ */
+export function createOtelLogger(config: OtelConfig): OtelLogger {
+  return new OtelLogger(config);
+}

package/src/core/tracer.ts

@@ -0,0 +1,213 @@
+import { randomBytes } from 'crypto';
+import { OtelConfig, SpanContext } from './types';
+import { OtelLogger } from './logger';
+
+interface SpanData {
+  traceId: string;
+  spanId: string;
+  parentSpanId?: string;
+  name: string;
+  kind: number;
+  startTimeUnixNano: string;
+  endTimeUnixNano: string;
+  attributes: Array<{ key: string; value: any }>;
+  events: Array<{ name: string; timeUnixNano: string; attributes?: any[] }>;
+  status: { code: number; message?: string };
+}
+
+export class OtelTracer {
+  private readonly collectorUrl: string;
+  private readonly serviceName: string;
+  private readonly logger: OtelLogger;
+  private component?: string;
+
+  constructor(config: OtelConfig, logger?: OtelLogger) {
+    this.collectorUrl = config.endpoint ? `${config.endpoint}/v1/traces` : '';
+    this.serviceName = config.serviceName || 'unknown-service';
+    this.logger = logger || new OtelLogger(config);
+  }
+
+  /**
+   * Create a component-scoped tracer
+   */
+  forComponent(component: string): OtelTracer {
+    const scoped = Object.create(this) as OtelTracer;
+    scoped.component = component;
+    return scoped;
+  }
+
+  private generateTraceId(): string {
+    return randomBytes(16).toString('hex');
+  }
+
+  private generateSpanId(): string {
+    return randomBytes(8).toString('hex');
+  }
+
+  private convertAttributes(
+    attrs: Record<string, any>,
+  ): Array<{ key: string; value: any }> {
+    return Object.entries(attrs).map(([key, value]) => {
+      if (typeof value === 'string') {
+        return { key, value: { stringValue: value } };
+      } else if (typeof value === 'number') {
+        return { key, value: { intValue: value } };
+      } else if (typeof value === 'boolean') {
+        return { key, value: { boolValue: value } };
+      } else {
+        return { key, value: { stringValue: String(value) } };
+      }
+    });
+  }
+
+  private async sendTraceToCollector(spans: SpanData[]): Promise<void> {
+    if (!this.collectorUrl) return;
+
+    const payload = {
+      resourceSpans: [
+        {
+          resource: {
+            attributes: [
+              { key: 'service.name', value: { stringValue: this.serviceName } },
+            ],
+          },
+          scopeSpans: [
+            {
+              scope: { name: 'app-tracer', version: '1.0.0' },
+              spans: spans.map((span) => ({
+                traceId: span.traceId,
+                spanId: span.spanId,
+                ...(span.parentSpanId
+                  ? { parentSpanId: span.parentSpanId }
+                  : {}),
+                name: span.name,
+                kind: span.kind,
+                startTimeUnixNano: span.startTimeUnixNano,
+                endTimeUnixNano: span.endTimeUnixNano,
+                attributes: span.attributes,
+                events: span.events,
+                status: span.status,
+              })),
+            },
+          ],
+        },
+      ],
+    };
+
+    try {
+      await fetch(this.collectorUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+    } catch {
+      // Silently fail
+    }
+  }
+
+  /**
+   * Trace a function execution
+   */
+  async trace<T>(
+    name: string,
+    fn: (ctx: SpanContext) => Promise<T>,
+    parentTraceId?: string,
+    parentSpanId?: string,
+  ): Promise<T> {
+    const traceId = parentTraceId || this.generateTraceId();
+    const spanId = this.generateSpanId();
+    const startTime = Date.now();
+
+    const attributes: Record<string, any> = {};
+    const events: Array<{
+      name: string;
+      timeUnixNano: string;
+      attributes?: any[];
+    }> = [];
+
+    const ctx: SpanContext = {
+      traceId,
+      spanId,
+      log: this.logger.withTrace(traceId, spanId, this.component),
+      setAttribute: (key: string, value: string | number | boolean) => {
+        attributes[key] = value;
+      },
+      addEvent: (eventName: string, attrs?: Record<string, any>) => {
+        events.push({
+          name: eventName,
+          timeUnixNano: String(Date.now() * 1000000),
+          attributes: attrs
+            ? Object.entries(attrs).map(([key, value]) => ({
+                key,
+                value: { stringValue: String(value) },
+              }))
+            : [],
+        });
+      },
+    };
+
+    try {
+      const result = await fn(ctx);
+
+      const spanData: SpanData = {
+        traceId,
+        spanId,
+        ...(parentSpanId ? { parentSpanId } : {}),
+        name,
+        kind: 1,
+        startTimeUnixNano: String(startTime * 1000000),
+        endTimeUnixNano: String(Date.now() * 1000000),
+        attributes: this.convertAttributes(attributes),
+        events,
+        status: { code: 1 },
+      };
+
+      await this.sendTraceToCollector([spanData]);
+
+      return result;
+    } catch (error) {
+      attributes['error'] = true;
+      attributes['error.message'] = (error as Error).message;
+      if ((error as Error).stack) {
+        attributes['error.stack'] = (error as Error).stack;
+      }
+
+      const spanData: SpanData = {
+        traceId,
+        spanId,
+        ...(parentSpanId ? { parentSpanId } : {}),
+        name,
+        kind: 1,
+        startTimeUnixNano: String(startTime * 1000000),
+        endTimeUnixNano: String(Date.now() * 1000000),
+        attributes: this.convertAttributes(attributes),
+        events,
+        status: { code: 2, message: (error as Error).message },
+      };
+
+      await this.sendTraceToCollector([spanData]);
+      throw error;
+    }
+  }
+
+  /**
+   * Create a child span within an existing trace
+   */
+  async childSpan<T>(
+    name: string,
+    fn: (ctx: SpanContext) => Promise<T>,
+    parentCtx: SpanContext,
+  ): Promise<T> {
+    return this.trace(name, fn, parentCtx.traceId, parentCtx.spanId);
+  }
+}
+
+/**
+ * Factory function to create a tracer instance
+ */
+export function createOtelTracer(
+  config: OtelConfig,
+  logger?: OtelLogger,
+): OtelTracer {
+  return new OtelTracer(config, logger);
+}

package/src/core/types.ts

@@ -0,0 +1,40 @@
+export interface OtelConfig {
+  endpoint: string;
+  serviceName: string;
+}
+
+export interface LogData {
+  message: string;
+  level: 'info' | 'warn' | 'error' | 'debug';
+  attributes?: Record<string, any>;
+  traceId?: string;
+  spanId?: string;
+  component?: string;
+}
+
+export interface SpanContext {
+  traceId: string;
+  spanId: string;
+  log: ScopedLogger;
+  setAttribute: (key: string, value: string | number | boolean) => void;
+  addEvent: (name: string, attrs?: Record<string, any>) => void;
+}
+
+export interface ScopedLogger {
+  info: (msg: string, attrs?: Record<string, any>) => void;
+  warn: (msg: string, attrs?: Record<string, any>) => void;
+  error: (
+    msg: string,
+    error?: Error | Record<string, any>,
+    attrs?: Record<string, any>,
+  ) => void;
+  debug: (msg: string, attrs?: Record<string, any>) => void;
+}
+
+export interface TracedLogger extends ScopedLogger {
+  withTrace: (traceId: string, spanId: string) => ScopedLogger;
+}
+
+export interface ComponentLogger extends ScopedLogger {
+  withTrace: (traceId: string, spanId: string) => ScopedLogger;
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+// Core (framework-agnostic)
+export * from './core';
+
+// NestJS integration
+export * from './nest';

package/src/nest/index.ts

@@ -0,0 +1,3 @@
+export * from './otel.module';
+export * from './otel-logger.service';
+export * from './otel-tracer.service';

package/src/nest/otel-logger.service.ts

@@ -0,0 +1,16 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { OtelLogger } from '../core/logger';
+
+/**
+ * NestJS injectable wrapper for OtelLogger
+ */
+@Injectable()
+export class OtelLoggerService extends OtelLogger {
+  constructor(config: ConfigService) {
+    super({
+      endpoint: config.get('OTEL_EXPORTER_OTLP_ENDPOINT', ''),
+      serviceName: config.get('OTEL_SERVICE_NAME', 'unknown-service'),
+    });
+  }
+}