@payloops/observability 0.0.8 → 0.0.11

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 import { NodeSDK } from '@opentelemetry/sdk-node';
-import pino from 'pino';
 import * as _opentelemetry_api from '@opentelemetry/api';
 
 interface TelemetryConfig {
@@ -16,24 +15,37 @@ interface TelemetryConfig {
 declare function initTelemetry(config: TelemetryConfig | string, serviceVersion?: string): NodeSDK;
 declare function shutdownTelemetry(): Promise<void>;
 
+interface Logger {
+    trace(msg: string): void;
+    trace(data: Record<string, unknown>, msg: string): void;
+    debug(msg: string): void;
+    debug(data: Record<string, unknown>, msg: string): void;
+    info(msg: string): void;
+    info(data: Record<string, unknown>, msg: string): void;
+    warn(msg: string): void;
+    warn(data: Record<string, unknown>, msg: string): void;
+    error(msg: string): void;
+    error(data: Record<string, unknown>, msg: string): void;
+    fatal(msg: string): void;
+    fatal(data: Record<string, unknown>, msg: string): void;
+    child(bindings: Record<string, unknown>): Logger;
+}
 /**
- * Base logger with trace context mixin
- * In development: pretty print to console + OTLP
- * In production: JSON to stdout + OTLP
+ * Base logger instance
  */
-declare const logger: pino.Logger<never, boolean>;
+declare const logger: Logger;
 /**
  * Create a child logger for a specific activity
  */
-declare function createActivityLogger(activityName: string, correlationId?: string): pino.Logger<never, boolean>;
+declare function createActivityLogger(activityName: string, correlationId?: string): Logger;
 /**
  * Create a child logger for a specific workflow
  */
-declare function createWorkflowLogger(workflowId: string, correlationId?: string): pino.Logger<never, boolean>;
+declare function createWorkflowLogger(workflowId: string, correlationId?: string): Logger;
 /**
  * Create a child logger for HTTP requests
  */
-declare function createRequestLogger(requestId: string, method: string, path: string): pino.Logger<never, boolean>;
+declare function createRequestLogger(requestId: string, method: string, path: string): Logger;
 
 /**
  * Correlation context for tracking requests across services

package/dist/index.js

@@ -284,9 +284,8 @@ function shutdownTelemetry() {
 }
 
 // src/lib/logger.ts
-import pino from "pino";
 import { trace } from "@opentelemetry/api";
-import { logs as logs2, SeverityNumber as SeverityNumber2 } from "@opentelemetry/api-logs";
+import { logs as logs2, SeverityNumber } from "@opentelemetry/api-logs";
 
 // src/lib/context.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -333,54 +332,63 @@ function createContextFromMemo(memo) {
 // src/lib/logger.ts
 var NODE_ENV = process.env.NODE_ENV || "development";
 var SERVICE_NAME = process.env.OTEL_SERVICE_NAME || "loop";
-var pinoLevelToOtelSeverity = {
-  10: SeverityNumber2.TRACE,
-  // trace
-  20: SeverityNumber2.DEBUG,
-  // debug
-  30: SeverityNumber2.INFO,
-  // info
-  40: SeverityNumber2.WARN,
-  // warn
-  50: SeverityNumber2.ERROR,
-  // error
-  60: SeverityNumber2.FATAL
-  // fatal
+var LOG_LEVEL = process.env.LOG_LEVEL || (NODE_ENV === "production" ? "info" : "debug");
+var colors = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m"
 };
-var traceMixin = () => {
-  const mixinData = {};
+var levelConfig = {
+  trace: { severity: SeverityNumber.TRACE, color: colors.dim, label: "TRACE", priority: 0 },
+  debug: { severity: SeverityNumber.DEBUG, color: colors.blue, label: "DEBUG", priority: 1 },
+  info: { severity: SeverityNumber.INFO, color: colors.green, label: "INFO", priority: 2 },
+  warn: { severity: SeverityNumber.WARN, color: colors.yellow, label: "WARN", priority: 3 },
+  error: { severity: SeverityNumber.ERROR, color: colors.red, label: "ERROR", priority: 4 },
+  fatal: { severity: SeverityNumber.FATAL, color: colors.magenta, label: "FATAL", priority: 5 }
+};
+var currentLevelPriority = levelConfig[LOG_LEVEL]?.priority ?? 2;
+function getContext() {
+  const ctx = {};
   const span = trace.getActiveSpan();
   if (span) {
     const spanContext = span.spanContext();
-    mixinData.trace_id = spanContext.traceId;
-    mixinData.span_id = spanContext.spanId;
+    ctx.trace_id = spanContext.traceId;
+    ctx.span_id = spanContext.spanId;
   }
   const correlationCtx = getCorrelationContext();
   if (correlationCtx) {
-    mixinData.correlation_id = correlationCtx.correlationId;
-    if (correlationCtx.merchantId) mixinData.merchant_id = correlationCtx.merchantId;
-    if (correlationCtx.orderId) mixinData.order_id = correlationCtx.orderId;
-    if (correlationCtx.workflowId) mixinData.workflow_id = correlationCtx.workflowId;
+    ctx.correlation_id = correlationCtx.correlationId;
+    if (correlationCtx.merchantId) ctx.merchant_id = correlationCtx.merchantId;
+    if (correlationCtx.orderId) ctx.order_id = correlationCtx.orderId;
+    if (correlationCtx.workflowId) ctx.workflow_id = correlationCtx.workflowId;
   }
-  return mixinData;
-};
-function emitToOtel(logRecord) {
+  return ctx;
+}
+function emitToOtel(level, message, attributes) {
   try {
-    const otelLogger = logs2.getLogger(SERVICE_NAME);
+    const provider = logs2.getLoggerProvider();
+    if (provider.constructor.name === "ProxyLoggerProvider") {
+      return;
+    }
+    const otelLogger = provider.getLogger(SERVICE_NAME);
     const span = trace.getActiveSpan();
     const spanContext = span?.spanContext();
+    const config = levelConfig[level];
     otelLogger.emit({
-      severityNumber: pinoLevelToOtelSeverity[logRecord.level] || SeverityNumber2.INFO,
-      severityText: pino.levels.labels[logRecord.level] || "INFO",
-      body: logRecord.msg,
+      severityNumber: config?.severity ?? SeverityNumber.INFO,
+      severityText: config?.label ?? "INFO",
+      body: message,
       attributes: {
-        ...logRecord,
-        // Remove fields that are part of the log record structure
-        msg: void 0,
-        level: void 0,
-        time: void 0
+        service: SERVICE_NAME,
+        env: NODE_ENV,
+        ...attributes
       },
-      timestamp: logRecord.time ? new Date(logRecord.time).getTime() * 1e6 : Date.now() * 1e6,
+      timestamp: Date.now() * 1e6,
       // nanoseconds
       ...spanContext && {
         spanId: spanContext.spanId,
@@ -391,65 +399,74 @@ function emitToOtel(logRecord) {
   } catch {
   }
 }
-var otelHooks = {
-  logMethod(inputArgs, method, level) {
-    method.apply(this, inputArgs);
-    const [objOrMsg, msgOrUndefined] = inputArgs;
-    const logRecord = {
-      level,
-      time: (/* @__PURE__ */ new Date()).toISOString(),
+function formatConsole(level, message, data) {
+  const config = levelConfig[level];
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const color = config?.color ?? colors.reset;
+  const label = config?.label ?? level.toUpperCase();
+  if (NODE_ENV === "production") {
+    return JSON.stringify({
+      time: timestamp,
+      level: label,
+      msg: message,
       service: SERVICE_NAME,
-      env: NODE_ENV
-    };
-    if (typeof objOrMsg === "object" && objOrMsg !== null) {
-      Object.assign(logRecord, objOrMsg);
-      logRecord.msg = msgOrUndefined || "";
-    } else {
-      logRecord.msg = objOrMsg;
-    }
-    Object.assign(logRecord, traceMixin());
-    emitToOtel(logRecord);
+      env: NODE_ENV,
+      ...data
+    });
   }
-};
-var logger = pino(
-  {
-    level: NODE_ENV === "production" ? "info" : "debug",
-    mixin: traceMixin,
-    base: {
-      service: SERVICE_NAME,
-      env: NODE_ENV
-    },
-    timestamp: pino.stdTimeFunctions.isoTime,
-    hooks: otelHooks,
-    // In development, use pino-pretty for console output
-    ...NODE_ENV !== "production" && {
-      transport: {
-        target: "pino-pretty",
-        options: { colorize: true }
-      }
+  const timeStr = `${colors.dim}[${timestamp.split("T")[1].slice(0, -1)}]${colors.reset}`;
+  const levelStr = `${color}${label.padEnd(5)}${colors.reset}`;
+  const msgStr = `${color}${message}${colors.reset}`;
+  const dataEntries = Object.entries(data).filter(([, v]) => v !== void 0);
+  const dataStr = dataEntries.length > 0 ? "\n" + dataEntries.map(([k, v]) => `    ${colors.magenta}${k}${colors.reset}: ${JSON.stringify(v)}`).join("\n") : "";
+  return `${timeStr} ${levelStr}: ${msgStr}${dataStr}`;
+}
+function log(level, msgOrData, msg) {
+  const config = levelConfig[level];
+  if (!config || config.priority < currentLevelPriority) {
+    return;
+  }
+  let message;
+  let data;
+  if (typeof msgOrData === "string") {
+    message = msgOrData;
+    data = {};
+  } else {
+    message = msg ?? "";
+    data = msgOrData;
+  }
+  const context2 = getContext();
+  const enrichedData = { ...data, ...context2 };
+  console.log(formatConsole(level, message, enrichedData));
+  emitToOtel(level, message, enrichedData);
+}
+function createLogger(bindings = {}) {
+  const boundLog = (level, msgOrData, msg) => {
+    if (typeof msgOrData === "string") {
+      log(level, { ...bindings }, msgOrData);
+    } else {
+      log(level, { ...bindings, ...msgOrData }, msg);
     }
-  },
-  // In production, also write JSON to stdout (in addition to OTLP via hooks)
-  NODE_ENV === "production" ? pino.destination(1) : void 0
-);
+  };
+  return {
+    trace: (msgOrData, msg) => boundLog("trace", msgOrData, msg),
+    debug: (msgOrData, msg) => boundLog("debug", msgOrData, msg),
+    info: (msgOrData, msg) => boundLog("info", msgOrData, msg),
+    warn: (msgOrData, msg) => boundLog("warn", msgOrData, msg),
+    error: (msgOrData, msg) => boundLog("error", msgOrData, msg),
+    fatal: (msgOrData, msg) => boundLog("fatal", msgOrData, msg),
+    child: (childBindings) => createLogger({ ...bindings, ...childBindings })
+  };
+}
+var logger = createLogger({ service: SERVICE_NAME, env: NODE_ENV });
 function createActivityLogger(activityName, correlationId) {
-  return logger.child({
-    activity: activityName,
-    correlationId
-  });
+  return logger.child({ activity: activityName, correlationId });
 }
 function createWorkflowLogger(workflowId, correlationId) {
-  return logger.child({
-    workflowId,
-    correlationId
-  });
+  return logger.child({ workflowId, correlationId });
 }
 function createRequestLogger(requestId, method, path) {
-  return logger.child({
-    requestId,
-    method,
-    path
-  });
+  return logger.child({ requestId, method, path });
 }
 
 // src/lib/metrics.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloops/observability",
-  "version": "0.0.8",
+  "version": "0.0.11",
   "type": "module",
   "repository": {
     "type": "git",
@@ -36,14 +36,12 @@
     "@opentelemetry/sdk-metrics": "^1.30.1",
     "@opentelemetry/sdk-node": "^0.57.0",
     "@opentelemetry/semantic-conventions": "^1.28.0",
-    "nanoid": "^5.0.9",
-    "pino": "^9.6.0"
+    "nanoid": "^5.0.9"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
     "@types/node": "^22.0.0",
     "eslint": "^9.0.0",
-    "pino-pretty": "^13.0.0",
     "tsup": "^8.3.5",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.53.0"