@shogo-ai/core 1.10.0 → 2.4.1

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export { LogLevel, Logger, createLogger } from './logger.js';
+export { LogEntry, LogLevel, LogSink, Logger, TraceContext, TraceContextProvider, createLogger, emitLogToSink, setOtelLogSink, setTraceContextProvider } from './logger.js';
 export { InstrumentationConfig, initInstrumentation, shutdownInstrumentation, traceOperation } from './instrumentation.js';
-export { ReplayOptions, StreamBufferStore, StreamBufferWriter, TurnSnapshot, TurnStatus, TurnTerminal, createBufferingTransform } from './stream-buffer.js';
+export { ReplayOptions, StreamBufferStore, StreamBufferWriter, TURN_COMPLETE_EVENT_TYPE, TURN_SEQ_EVENT_TYPE, TurnCompleteFrameData, TurnReply, TurnSnapshot, TurnStatus, TurnTerminal, compactSseFrames, createBufferingTransform, encodeTurnCompleteFrame, encodeTurnSeqFrame } from './stream-buffer.js';
 export { extractUserText, findLastUserMessage } from './chat-message.js';
 export { isMacOSJunkName, isMacOSJunkPath } from './macos-junk.js';
-export { StackRegistryEntry, StackTarget, TECH_STACK_REGISTRY, getStackEntry, isMobileTechStack, stackSeedsItself, usesMetroBundler } from './tech-stack-registry.js';
-export { BINARY_FILE_EXTENSIONS, isBinaryFilePath } from './file-types.js';
+export { StackRegistryEntry, StackTarget, TECH_STACK_REGISTRY, getDeclaredPorts, getMinimumInstanceSize, getStackEntry, isDockerTechStack, isMobileTechStack, stackSeedsItself, usesMetroBundler } from './tech-stack-registry.js';
+export { BINARY_FILE_BASENAMES, BINARY_FILE_EXTENSIONS, BINARY_FILE_TRANSIENT_SUFFIXES, isBinaryBuffer, isBinaryFilePath } from './file-types.js';
 import '@opentelemetry/api';

package/dist/index.js

@@ -3,46 +3,74 @@ import {
   findLastUserMessage
 } from "./chunk-4J7NH2WJ.js";
 import {
+  BINARY_FILE_BASENAMES,
   BINARY_FILE_EXTENSIONS,
+  BINARY_FILE_TRANSIENT_SUFFIXES,
+  isBinaryBuffer,
   isBinaryFilePath
-} from "./chunk-HKX3MEJN.js";
+} from "./chunk-MDRCI2CN.js";
 import {
   initInstrumentation,
   shutdownInstrumentation,
   traceOperation
-} from "./chunk-IDGVRGAL.js";
+} from "./chunk-WRHTXHTH.js";
 import {
-  createLogger
-} from "./chunk-24AL3V6R.js";
+  createLogger,
+  emitLogToSink,
+  setOtelLogSink,
+  setTraceContextProvider
+} from "./chunk-VW6ZGCBI.js";
 import {
   isMacOSJunkName,
   isMacOSJunkPath
 } from "./chunk-VTD7O7YC.js";
 import {
   StreamBufferStore,
-  createBufferingTransform
-} from "./chunk-ELMG6OXT.js";
+  TURN_COMPLETE_EVENT_TYPE,
+  TURN_SEQ_EVENT_TYPE,
+  compactSseFrames,
+  createBufferingTransform,
+  encodeTurnCompleteFrame,
+  encodeTurnSeqFrame
+} from "./chunk-H625AGFN.js";
 import {
   TECH_STACK_REGISTRY,
+  getDeclaredPorts,
+  getMinimumInstanceSize,
   getStackEntry,
+  isDockerTechStack,
   isMobileTechStack,
   stackSeedsItself,
   usesMetroBundler
-} from "./chunk-KTDDFWXM.js";
+} from "./chunk-NTAY4E43.js";
 export {
+  BINARY_FILE_BASENAMES,
   BINARY_FILE_EXTENSIONS,
+  BINARY_FILE_TRANSIENT_SUFFIXES,
   StreamBufferStore,
   TECH_STACK_REGISTRY,
+  TURN_COMPLETE_EVENT_TYPE,
+  TURN_SEQ_EVENT_TYPE,
+  compactSseFrames,
   createBufferingTransform,
   createLogger,
+  emitLogToSink,
+  encodeTurnCompleteFrame,
+  encodeTurnSeqFrame,
   extractUserText,
   findLastUserMessage,
+  getDeclaredPorts,
+  getMinimumInstanceSize,
   getStackEntry,
   initInstrumentation,
+  isBinaryBuffer,
   isBinaryFilePath,
+  isDockerTechStack,
   isMacOSJunkName,
   isMacOSJunkPath,
   isMobileTechStack,
+  setOtelLogSink,
+  setTraceContextProvider,
   shutdownInstrumentation,
   stackSeedsItself,
   traceOperation,

package/dist/instrumentation.cjs

@@ -26,13 +26,43 @@ __export(instrumentation_exports, {
 });
 module.exports = __toCommonJS(instrumentation_exports);
 var import_api = require("@opentelemetry/api");
+var import_api_logs = require("@opentelemetry/api-logs");
 var import_sdk_node = require("@opentelemetry/sdk-node");
 var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
 var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_sdk_logs = require("@opentelemetry/sdk-logs");
 var import_resources = require("@opentelemetry/resources");
 var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+
+// src/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var isProduction = process.env.NODE_ENV === "production" || process.env.NODE_ENV === "staging";
+var minLevel = LOG_LEVELS[process.env.LOG_LEVEL || "info"] ?? 1;
+var logSink = null;
+function setOtelLogSink(sink) {
+  logSink = sink;
+}
+var traceContextProvider = null;
+function setTraceContextProvider(provider) {
+  traceContextProvider = provider;
+}
+
+// src/instrumentation.ts
+var SEVERITY_BY_LEVEL = {
+  debug: { number: import_api_logs.SeverityNumber.DEBUG, text: "DEBUG" },
+  info: { number: import_api_logs.SeverityNumber.INFO, text: "INFO" },
+  warn: { number: import_api_logs.SeverityNumber.WARN, text: "WARN" },
+  error: { number: import_api_logs.SeverityNumber.ERROR, text: "ERROR" }
+};
 var sdk = null;
 function initInstrumentation(config) {
+  if (sdk) return;
   const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
   if (!endpoint) {
     console.log(`[OTEL] Tracing disabled for ${config.serviceName} (OTEL_EXPORTER_OTLP_ENDPOINT not set)`);
@@ -46,18 +76,43 @@ function initInstrumentation(config) {
   }
   const serviceName = process.env.OTEL_SERVICE_NAME || config.serviceName;
   console.log(`[OTEL] Configuring ${serviceName} \u2192 ${endpoint}/v1/traces`);
+  const exportTimeoutMs = Number(process.env.OTEL_EXPORTER_TIMEOUT_MS ?? 3e3);
   let traceExporter;
   try {
     traceExporter = new import_exporter_trace_otlp_http.OTLPTraceExporter({
       url: `${endpoint}/v1/traces`,
-      headers
+      headers,
+      timeoutMillis: exportTimeoutMs
     });
   } catch (err) {
     console.error(`[OTEL] Failed to create exporter: ${err.message}`);
     return;
   }
-  const isProduction = process.env.NODE_ENV === "production" || process.env.NODE_ENV === "staging";
-  const spanProcessor = isProduction ? new import_sdk_trace_base.BatchSpanProcessor(traceExporter) : new import_sdk_trace_base.SimpleSpanProcessor(traceExporter);
+  const isProduction2 = process.env.NODE_ENV === "production" || process.env.NODE_ENV === "staging";
+  const spanProcessor = isProduction2 ? new import_sdk_trace_base.BatchSpanProcessor(traceExporter, {
+    maxQueueSize: 2048,
+    maxExportBatchSize: 512,
+    scheduledDelayMillis: 5e3,
+    exportTimeoutMillis: exportTimeoutMs
+  }) : new import_sdk_trace_base.SimpleSpanProcessor(traceExporter);
+  let logRecordProcessors = [];
+  try {
+    const logExporter = new import_exporter_logs_otlp_http.OTLPLogExporter({
+      url: `${endpoint}/v1/logs`,
+      headers,
+      timeoutMillis: exportTimeoutMs
+    });
+    logRecordProcessors = [
+      isProduction2 ? new import_sdk_logs.BatchLogRecordProcessor(logExporter, {
+        maxQueueSize: 2048,
+        maxExportBatchSize: 512,
+        scheduledDelayMillis: 5e3,
+        exportTimeoutMillis: exportTimeoutMs
+      }) : new import_sdk_logs.SimpleLogRecordProcessor(logExporter)
+    ];
+  } catch (err) {
+    console.warn(`[OTEL] Failed to create log exporter for ${serviceName}: ${err.message}`);
+  }
   sdk = new import_sdk_node.NodeSDK({
     resource: (0, import_resources.resourceFromAttributes)({
       [import_semantic_conventions.ATTR_SERVICE_NAME]: serviceName,
@@ -65,6 +120,7 @@ function initInstrumentation(config) {
       "deployment.environment.name": process.env.NODE_ENV || "development"
     }),
     spanProcessors: [spanProcessor],
+    logRecordProcessors,
     instrumentations: []
   });
   try {
@@ -75,6 +131,24 @@ function initInstrumentation(config) {
     sdk = null;
     return;
   }
+  setTraceContextProvider(() => {
+    const ctx = import_api.trace.getActiveSpan()?.spanContext();
+    return ctx && (0, import_api.isSpanContextValid)(ctx) ? { trace_id: ctx.traceId, span_id: ctx.spanId } : null;
+  });
+  if (logRecordProcessors.length > 0) {
+    const otelLogger = import_api_logs.logs.getLogger(serviceName);
+    setOtelLogSink((entry) => {
+      const { level, msg, service, timestamp, ...attrs } = entry;
+      const severity = SEVERITY_BY_LEVEL[level] ?? SEVERITY_BY_LEVEL.info;
+      otelLogger.emit({
+        severityNumber: severity.number,
+        severityText: severity.text,
+        body: msg,
+        attributes: { service, ...attrs }
+      });
+    });
+    console.log(`[OTEL] Logs exporter enabled for ${serviceName} \u2192 ${endpoint}/v1/logs`);
+  }
   try {
     const tracer = import_api.trace.getTracer(serviceName);
     const testSpan = tracer.startSpan("otel.startup-test", {
@@ -95,13 +169,24 @@ function initInstrumentation(config) {
   }
 }
 async function shutdownInstrumentation() {
-  if (sdk) {
-    try {
-      await sdk.shutdown();
-      console.log("[OTEL] Tracing shut down");
-    } catch (err) {
-      console.error("[OTEL] Error shutting down:", err.message);
-    }
+  if (!sdk) return;
+  setOtelLogSink(null);
+  setTraceContextProvider(null);
+  const shutdownTimeoutMs = Number(process.env.OTEL_SHUTDOWN_TIMEOUT_MS ?? 2e3);
+  let timer;
+  try {
+    await Promise.race([
+      sdk.shutdown(),
+      new Promise((resolve) => {
+        timer = setTimeout(resolve, shutdownTimeoutMs);
+      })
+    ]);
+    console.log("[OTEL] Tracing shut down");
+  } catch (err) {
+    console.error("[OTEL] Error shutting down:", err.message);
+  } finally {
+    if (timer) clearTimeout(timer);
+    sdk = null;
   }
 }
 function traceOperation(tracerName, spanName, attributes, fn) {

package/dist/instrumentation.js

@@ -2,7 +2,8 @@ import {
   initInstrumentation,
   shutdownInstrumentation,
   traceOperation
-} from "./chunk-IDGVRGAL.js";
+} from "./chunk-WRHTXHTH.js";
+import "./chunk-VW6ZGCBI.js";
 export {
   initInstrumentation,
   shutdownInstrumentation,

package/dist/logger.cjs

@@ -20,7 +20,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/logger.ts
 var logger_exports = {};
 __export(logger_exports, {
-  createLogger: () => createLogger
+  createLogger: () => createLogger,
+  emitLogToSink: () => emitLogToSink,
+  setOtelLogSink: () => setOtelLogSink,
+  setTraceContextProvider: () => setTraceContextProvider
 });
 module.exports = __toCommonJS(logger_exports);
 var LOG_LEVELS = {
@@ -42,6 +45,21 @@ function formatEntry(entry) {
   const extraStr = Object.keys(extra).length > 0 ? " " + JSON.stringify(extra) : "";
   return `[${service}] ${msg}${extraStr}`;
 }
+var logSink = null;
+function setOtelLogSink(sink) {
+  logSink = sink;
+}
+function emitLogToSink(entry) {
+  if (!logSink) return;
+  try {
+    logSink({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
+  } catch {
+  }
+}
+var traceContextProvider = null;
+function setTraceContextProvider(provider) {
+  traceContextProvider = provider;
+}
 function createLogger(service, defaultExtra) {
   function log(level, msg, extra) {
     if (!shouldLog(level)) return;
@@ -53,6 +71,16 @@ function createLogger(service, defaultExtra) {
       ...defaultExtra,
       ...extra
     };
+    if (traceContextProvider) {
+      try {
+        const tc = traceContextProvider();
+        if (tc) {
+          entry.trace_id = tc.trace_id;
+          entry.span_id = tc.span_id;
+        }
+      } catch {
+      }
+    }
     const formatted = formatEntry(entry);
     switch (level) {
       case "error":
@@ -65,6 +93,12 @@ function createLogger(service, defaultExtra) {
         console.log(formatted);
         break;
     }
+    if (logSink) {
+      try {
+        logSink(entry);
+      } catch {
+      }
+    }
   }
   return {
     debug: (msg, extra) => log("debug", msg, extra),
@@ -76,6 +110,9 @@ function createLogger(service, defaultExtra) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createLogger
+  createLogger,
+  emitLogToSink,
+  setOtelLogSink,
+  setTraceContextProvider
 });
 //# sourceMappingURL=logger.cjs.map

package/dist/logger.d.cts

@@ -19,6 +19,13 @@
  *   reqLog.warn('slow query', { ms: 4200 })
  */
 type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LogEntry {
+    level: LogLevel;
+    msg: string;
+    service: string;
+    timestamp: string;
+    [key: string]: unknown;
+}
 interface Logger {
     debug(msg: string, extra?: Record<string, unknown>): void;
     info(msg: string, extra?: Record<string, unknown>): void;
@@ -27,6 +34,69 @@ interface Logger {
     /** Returns a new logger that merges `extra` into every log entry. */
     child(extra: Record<string, unknown>): Logger;
 }
+/**
+ * Optional sink that forwards every emitted log entry to an external
+ * destination (e.g. an OpenTelemetry `LoggerProvider` for OTLP export to
+ * SigNoz). Kept as a plain callback so this module has ZERO OpenTelemetry
+ * dependency — `instrumentation.ts` installs the sink only when OTEL is
+ * configured, and userland consumers that just want a console logger are
+ * unaffected. See `setOtelLogSink`.
+ */
+type LogSink = (entry: LogEntry) => void;
+/**
+ * Register (or clear, with `null`) a sink invoked for every log entry after
+ * it is written to the console. Errors thrown by the sink are swallowed —
+ * telemetry must never break application logging.
+ */
+declare function setOtelLogSink(sink: LogSink | null): void;
+/**
+ * Forward a pre-built structured entry to the OTEL log sink (if one is
+ * installed via `setOtelLogSink`) WITHOUT writing it to the console.
+ *
+ * `createLogger` always writes to the console *and* the sink. Some callers
+ * already persist the line through another channel — e.g. the agent-runtime
+ * writes a project's build/console stdout+stderr to on-disk log files — and
+ * only need the *additional* OTLP export copy for SigNoz. Routing those lines
+ * through `createLogger` would re-print every one of them to the process's own
+ * stdout (doubling the on-disk logs and the volume), so this bypasses the
+ * console and emits straight to the sink.
+ *
+ * No-op when no sink is installed (e.g. OTEL disabled), so it is always safe to
+ * call unconditionally. Errors thrown by the sink are swallowed — telemetry
+ * must never break the caller. `timestamp` defaults to now; any extra fields
+ * become OTLP log-record attributes.
+ */
+declare function emitLogToSink(entry: {
+    level: LogLevel;
+    msg: string;
+    service: string;
+    timestamp?: string;
+    [key: string]: unknown;
+}): void;
+/** Active trace context, in OpenTelemetry hex form (32-char / 16-char). */
+interface TraceContext {
+    trace_id: string;
+    span_id: string;
+}
+/**
+ * Optional provider of the active trace context, used to stamp `trace_id` /
+ * `span_id` onto every log entry so the *stdout line itself* is trace-
+ * correlated. This is the durable "trace-ids-on-stdout" path: a log scraper
+ * (the SigNoz k8s-infra DaemonSet, or a host collector tailing serial output
+ * on bare-metal guests) can then link logs to traces WITHOUT depending on the
+ * app-level OTLP log export, which is unreliable under Bun event-loop pressure.
+ *
+ * Kept as a plain callback so this module keeps ZERO OpenTelemetry dependency —
+ * `instrumentation.ts` registers it once a tracer is live, and userland
+ * consumers that just want a console logger are unaffected.
+ */
+type TraceContextProvider = () => TraceContext | null;
+/**
+ * Register (or clear, with `null`) the provider consulted on every log call to
+ * enrich entries with the active `trace_id` / `span_id`. Errors thrown by the
+ * provider are swallowed — telemetry must never break application logging.
+ */
+declare function setTraceContextProvider(provider: TraceContextProvider | null): void;
 declare function createLogger(service: string, defaultExtra?: Record<string, unknown>): Logger;
 
-export { type LogLevel, type Logger, createLogger };
+export { type LogEntry, type LogLevel, type LogSink, type Logger, type TraceContext, type TraceContextProvider, createLogger, emitLogToSink, setOtelLogSink, setTraceContextProvider };

package/dist/logger.d.ts

@@ -19,6 +19,13 @@
  *   reqLog.warn('slow query', { ms: 4200 })
  */
 type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LogEntry {
+    level: LogLevel;
+    msg: string;
+    service: string;
+    timestamp: string;
+    [key: string]: unknown;
+}
 interface Logger {
     debug(msg: string, extra?: Record<string, unknown>): void;
     info(msg: string, extra?: Record<string, unknown>): void;
@@ -27,6 +34,69 @@ interface Logger {
     /** Returns a new logger that merges `extra` into every log entry. */
     child(extra: Record<string, unknown>): Logger;
 }
+/**
+ * Optional sink that forwards every emitted log entry to an external
+ * destination (e.g. an OpenTelemetry `LoggerProvider` for OTLP export to
+ * SigNoz). Kept as a plain callback so this module has ZERO OpenTelemetry
+ * dependency — `instrumentation.ts` installs the sink only when OTEL is
+ * configured, and userland consumers that just want a console logger are
+ * unaffected. See `setOtelLogSink`.
+ */
+type LogSink = (entry: LogEntry) => void;
+/**
+ * Register (or clear, with `null`) a sink invoked for every log entry after
+ * it is written to the console. Errors thrown by the sink are swallowed —
+ * telemetry must never break application logging.
+ */
+declare function setOtelLogSink(sink: LogSink | null): void;
+/**
+ * Forward a pre-built structured entry to the OTEL log sink (if one is
+ * installed via `setOtelLogSink`) WITHOUT writing it to the console.
+ *
+ * `createLogger` always writes to the console *and* the sink. Some callers
+ * already persist the line through another channel — e.g. the agent-runtime
+ * writes a project's build/console stdout+stderr to on-disk log files — and
+ * only need the *additional* OTLP export copy for SigNoz. Routing those lines
+ * through `createLogger` would re-print every one of them to the process's own
+ * stdout (doubling the on-disk logs and the volume), so this bypasses the
+ * console and emits straight to the sink.
+ *
+ * No-op when no sink is installed (e.g. OTEL disabled), so it is always safe to
+ * call unconditionally. Errors thrown by the sink are swallowed — telemetry
+ * must never break the caller. `timestamp` defaults to now; any extra fields
+ * become OTLP log-record attributes.
+ */
+declare function emitLogToSink(entry: {
+    level: LogLevel;
+    msg: string;
+    service: string;
+    timestamp?: string;
+    [key: string]: unknown;
+}): void;
+/** Active trace context, in OpenTelemetry hex form (32-char / 16-char). */
+interface TraceContext {
+    trace_id: string;
+    span_id: string;
+}
+/**
+ * Optional provider of the active trace context, used to stamp `trace_id` /
+ * `span_id` onto every log entry so the *stdout line itself* is trace-
+ * correlated. This is the durable "trace-ids-on-stdout" path: a log scraper
+ * (the SigNoz k8s-infra DaemonSet, or a host collector tailing serial output
+ * on bare-metal guests) can then link logs to traces WITHOUT depending on the
+ * app-level OTLP log export, which is unreliable under Bun event-loop pressure.
+ *
+ * Kept as a plain callback so this module keeps ZERO OpenTelemetry dependency —
+ * `instrumentation.ts` registers it once a tracer is live, and userland
+ * consumers that just want a console logger are unaffected.
+ */
+type TraceContextProvider = () => TraceContext | null;
+/**
+ * Register (or clear, with `null`) the provider consulted on every log call to
+ * enrich entries with the active `trace_id` / `span_id`. Errors thrown by the
+ * provider are swallowed — telemetry must never break application logging.
+ */
+declare function setTraceContextProvider(provider: TraceContextProvider | null): void;
 declare function createLogger(service: string, defaultExtra?: Record<string, unknown>): Logger;
 
-export { type LogLevel, type Logger, createLogger };
+export { type LogEntry, type LogLevel, type LogSink, type Logger, type TraceContext, type TraceContextProvider, createLogger, emitLogToSink, setOtelLogSink, setTraceContextProvider };

package/dist/logger.js

@@ -1,7 +1,13 @@
 import {
-  createLogger
-} from "./chunk-24AL3V6R.js";
+  createLogger,
+  emitLogToSink,
+  setOtelLogSink,
+  setTraceContextProvider
+} from "./chunk-VW6ZGCBI.js";
 export {
-  createLogger
+  createLogger,
+  emitLogToSink,
+  setOtelLogSink,
+  setTraceContextProvider
 };
 //# sourceMappingURL=logger.js.map