@sebspark/otel 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -1,79 +1,561 @@
 // src/otel.ts
-import { DiagConsoleLogger, DiagLogLevel, diag } from "@opentelemetry/api";
+import {
+  context,
+  DiagConsoleLogger,
+  DiagLogLevel,
+  diag
+} from "@opentelemetry/api";
 import { logs } from "@opentelemetry/api-logs";
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+
+// src/providers.ts
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import {
-  detectResources,
-  resourceFromAttributes
-} from "@opentelemetry/resources";
 import {
   BatchLogRecordProcessor,
-  LoggerProvider
+  LoggerProvider,
+  SimpleLogRecordProcessor
 } from "@opentelemetry/sdk-logs";
 import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { NodeSDK } from "@opentelemetry/sdk-node";
+import {
+  BatchSpanProcessor
+} from "@opentelemetry/sdk-trace-node";
+
+// src/loggers/console-log-pretty-exporter.ts
+import { ExportResultCode } from "@opentelemetry/core";
+
+// src/consts.ts
+var LOG_SEVERITY_MAP = {
+  TRACE: 1,
+  DEBUG: 5,
+  INFO: 9,
+  NOTICE: 10,
+  WARNING: 13,
+  WARN: 13,
+  ERROR: 17,
+  FATAL: 21,
+  CRITICAL: 21,
+  ALERT: 22,
+  EMERGENCY: 23
+};
+
+// src/loggers/formatters/shared.ts
 import {
   ATTR_SERVICE_NAME,
   ATTR_SERVICE_VERSION
 } from "@opentelemetry/semantic-conventions";
-diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.ERROR);
-var serviceName = process.env.OTEL_SERVICE_NAME ?? "unknown-service";
-var otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://localhost:4318";
-var traceExporter = new OTLPTraceExporter({
-  url: `${otlpEndpoint}/v1/traces`
-});
-var metricExporter = new OTLPMetricExporter({
-  url: `${otlpEndpoint}/v1/metrics`
-});
-var logExporter = new OTLPLogExporter({ url: `${otlpEndpoint}/v1/logs` });
-var metricReader = new PeriodicExportingMetricReader({
-  exporter: metricExporter
-});
-async function initialize() {
-  try {
-    const baseRes = await detectResources();
-    const customRes = resourceFromAttributes({
-      [ATTR_SERVICE_NAME]: serviceName,
-      [ATTR_SERVICE_VERSION]: "1.0.0"
-    });
-    const resource = baseRes.merge(customRes);
-    const logProvider = new LoggerProvider({
-      resource,
-      processors: [new BatchLogRecordProcessor(logExporter)]
-    });
-    logs.setGlobalLoggerProvider(logProvider);
-    const sdk = new NodeSDK({
-      traceExporter,
-      metricReader,
-      instrumentations: [getNodeAutoInstrumentations()],
-      resource
+import stringify from "fast-safe-stringify";
+
+// src/loggers/formatters/style.ts
+import kleur from "kleur";
+var colors = {
+  gray: kleur.gray,
+  dim: kleur.dim,
+  cyan: kleur.cyan,
+  white: kleur.white,
+  green: kleur.green,
+  yellow: kleur.yellow,
+  red: kleur.red,
+  magenta: kleur.magenta
+};
+var levelColorMap = {
+  DEBUG: kleur.magenta,
+  INFO: kleur.green,
+  WARN: kleur.yellow,
+  ERROR: kleur.red,
+  FATAL: kleur.red
+};
+var levelIconMap = {
+  DEBUG: "\u{1F41B}",
+  INFO: "\u2139\uFE0F ",
+  WARN: "\u26A0\uFE0F ",
+  ERROR: "\u274C",
+  FATAL: "\u{1F480}"
+};
+var statusLabelMap = {
+  0: "UNSET",
+  1: "OK",
+  2: "ERROR"
+};
+var statusColorMap = {
+  0: colors.gray,
+  // UNSET
+  1: colors.green,
+  // OK
+  2: colors.red
+  // ERROR
+};
+var kindColorMap = {
+  0: colors.white,
+  // INTERNAL
+  1: colors.cyan,
+  // SERVER
+  2: colors.yellow,
+  // CLIENT
+  3: colors.magenta,
+  // PRODUCER
+  4: colors.green
+  // CONSUMER
+};
+
+// src/loggers/formatters/shared.ts
+function formatTimestamp(time) {
+  const date = new Date(hrTimeToMillis(time));
+  return colors.dim(date.toISOString().slice(11, 23));
+}
+function formatService(resource) {
+  const name = resource.attributes[ATTR_SERVICE_NAME] ?? "unknown-service";
+  const version = resource.attributes[ATTR_SERVICE_VERSION] ?? "1.0.0";
+  return colors.gray(`[${name}@${version}]`);
+}
+function formatLevel(record) {
+  const text = (record.severityText ?? "INFO").toUpperCase();
+  const colorFn = levelColorMap[text] ?? colors.white;
+  const icon = levelIconMap[text] ?? "\u2022";
+  return `${icon}  ${colorFn(text.padEnd(5))}`;
+}
+function formatScope(resource, instrumentationScope) {
+  const component = resource.attributes["component.name"];
+  const { name, version } = instrumentationScope;
+  const scopeLabel = component || (name && name !== "unknown" ? name : void 0);
+  if (!scopeLabel) return "";
+  const versionLabel = version ? `@${version}` : "";
+  return colors.cyan(`${scopeLabel}${versionLabel} `);
+}
+function formatMessage(record) {
+  return typeof record.body === "string" ? record.body : stringify(record.body);
+}
+function formatAttributes(attrs) {
+  const keys = Object.keys(attrs).filter(
+    (k) => !k.startsWith("service.") && !k.startsWith("serviceContext.")
+  );
+  if (keys.length === 0) return "";
+  const formatted = keys.map((k) => {
+    const val = attrs[k];
+    return `${k}=${typeof val === "object" ? stringify(val) : val}`;
+  });
+  return `  ${colors.gray(formatted.join(" "))}`;
+}
+function hrTimeToMillis(hrTime) {
+  return hrTime[0] * 1e3 + Math.floor(hrTime[1] / 1e6);
+}
+function calculateDuration(span) {
+  const start = hrTimeToMillis(span.startTime);
+  const end = hrTimeToMillis(span.endTime);
+  return Math.max(0, Math.round(end - start));
+}
+
+// src/loggers/formatters/log-record.ts
+function formatLogRecord(record) {
+  const timestamp = formatTimestamp(record.hrTime);
+  const service = formatService(record.resource);
+  const level = formatLevel(record);
+  const scope = formatScope(record.resource, record.instrumentationScope);
+  const message = formatMessage(record);
+  const attrs = formatAttributes(record.attributes);
+  return `${service} ${timestamp}  ${level}  ${scope}${message}${attrs}`;
+}
+
+// src/loggers/formatters/metrics.ts
+function formatMetrics(resourceMetrics) {
+  const { resource, scopeMetrics } = resourceMetrics;
+  return scopeMetrics.map((scopeMetric) => formatScopeMetric(scopeMetric, resource)).join("\n");
+}
+function formatScopeMetric(scopeMetric, resource) {
+  return scopeMetric.metrics.map(
+    (metric) => formatMetricData(metric, resource, scopeMetric.scope)
+  ).join("\n");
+}
+function formatMetricData(metric, resource, scope) {
+  const scopeStr = formatScope(resource, scope);
+  const serviceStr = formatService(resource);
+  const lines = [];
+  for (const dp of metric.dataPoints) {
+    const ts = formatTimestamp(dp.startTime);
+    const value = extractMetricValue(dp);
+    const attrs = formatAttributes(dp.attributes ?? {});
+    lines.push(
+      `${serviceStr} ${ts}  \u{1F4CA}  ${scopeStr}${colors.white(metric.descriptor.name)} ${colors.dim(value)}${attrs}`
+    );
+  }
+  return lines.join("\n");
+}
+function extractMetricValue(dp) {
+  const value = dp.value;
+  if (typeof value === "number") {
+    return value.toString();
+  }
+  if (isHistogramLike(value)) {
+    return value.sum.toString();
+  }
+  return "[complex]";
+}
+function isHistogramLike(val) {
+  return typeof val === "object" && val !== null && "sum" in val && typeof val.sum === "number";
+}
+
+// src/loggers/formatters/span.ts
+import { SpanStatusCode } from "@opentelemetry/api";
+function formatSpans(spans) {
+  const rootSpan = spans[0];
+  const rootStart = hrTimeToMillis(rootSpan.startTime);
+  const rootEnd = hrTimeToMillis(rootSpan.endTime);
+  const totalDuration = rootEnd - rootStart;
+  const service = formatService(rootSpan.resource);
+  const timestamp = formatTimestamp(rootSpan.startTime);
+  const lines = [`${service} ${timestamp}`];
+  for (const span of spans) {
+    const offset = hrTimeToMillis(span.startTime) - rootStart;
+    const depth = computeDepth(span, spans);
+    lines.push(
+      formatSpan(span, {
+        offsetMs: offset,
+        totalDurationMs: totalDuration,
+        depth
+      })
+    );
+  }
+  return lines.join("\n");
+}
+function formatSpan(span, opts) {
+  const label = formatLabel(span, opts.depth);
+  const bar = buildBar(span, opts?.offsetMs, opts?.totalDurationMs);
+  const barColor = span.status.code === SpanStatusCode.OK ? colors.green : span.status.code === SpanStatusCode.ERROR ? colors.red : colors.gray;
+  const desc = formatDescription(span);
+  const status = formatStatus(span);
+  const duration = formatDuration(span, opts?.offsetMs);
+  return `${label} ${barColor(bar)} ${desc} ${status} (${duration})`;
+}
+var LABEL_WIDTH = 25;
+function formatLabel(span, depth) {
+  const indent = "  ".repeat(depth);
+  const label = `${indent}\u2514\u2500 ${span.name}`;
+  return label.padEnd(LABEL_WIDTH);
+}
+var BAR_MIN_WIDTH = 1;
+var BAR_MAX_WIDTH = 20;
+function buildBar(span, offsetMs, totalDurationMs) {
+  const duration = calculateDuration(span);
+  if (typeof offsetMs !== "number" || typeof totalDurationMs !== "number" || totalDurationMs === 0) {
+    const capped = Math.min(duration, 1e3);
+    const barLength = Math.max(
+      BAR_MIN_WIDTH,
+      Math.round(capped / 1e3 * BAR_MAX_WIDTH)
+    );
+    return "\u2588".repeat(barLength).padEnd(BAR_MAX_WIDTH + 2);
+  }
+  const offsetRatio = Math.max(0, Math.min(offsetMs / totalDurationMs, 1));
+  const durationRatio = Math.max(0, Math.min(duration / totalDurationMs, 1));
+  const offsetChars = Math.floor(offsetRatio * BAR_MAX_WIDTH);
+  const barChars = Math.max(
+    BAR_MIN_WIDTH,
+    Math.round(durationRatio * BAR_MAX_WIDTH)
+  );
+  const empty = " ".repeat(offsetChars);
+  const bar = "\u2588".repeat(barChars);
+  return (empty + bar).padEnd(BAR_MAX_WIDTH + 2);
+}
+var DESCRIPTION_MAX_WIDTH = 20;
+function formatDescription(span) {
+  const keyPriority = [
+    // HTTP
+    ["http.method", "http.target"],
+    // → GET /users/123
+    ["http.route"],
+    // → /users/:id
+    ["http.url"],
+    // → https://...
+    // GraphQL
+    ["graphql.operation.name"],
+    // → getUsers
+    ["graphql.operation.type"],
+    // → query
+    ["graphql.document"],
+    // → full query text (maybe too long)
+    // WebSocket
+    ["ws.event"],
+    // → connection, message, disconnect
+    ["ws.message_type"],
+    // → ping/pong/text/binary
+    ["ws.url"],
+    // → wss://...
+    // Redis
+    ["db.system", "db.statement"],
+    // → redis, "SET foo bar"
+    ["db.operation"],
+    // → GET, SET
+    // Spanner
+    ["db.statement"],
+    // → SELECT * FROM...
+    ["db.operation"],
+    // → SELECT, INSERT
+    ["db.name"],
+    // → projects/.../instances/.../databases/...
+    // OpenSearch
+    ["db.operation"],
+    // → search, index, bulk
+    ["db.statement"],
+    // → { query DSL... }
+    // Pub/Sub (GCP)
+    ["messaging.operation"],
+    // → publish, receive
+    ["messaging.destination"],
+    // → topic-a
+    ["messaging.gcp_pubsub.topic"],
+    // → projects/x/topics/y
+    // General FaaS
+    ["faas.invoked_name"],
+    // → myFunction
+    ["faas.trigger"],
+    // → http, pubsub, etc.
+    // Custom or fallback
+    ["otel.description"]
+  ];
+  for (const keys of keyPriority) {
+    const parts = keys.map((k) => span.attributes[k]).filter((v) => v !== void 0 && v !== null).map((v) => String(v));
+    if (parts.length > 0) {
+      return truncate(parts.join(" "), DESCRIPTION_MAX_WIDTH - 1).padEnd(
+        DESCRIPTION_MAX_WIDTH
+      );
+    }
+  }
+  return "".padEnd(DESCRIPTION_MAX_WIDTH);
+}
+function formatStatus(span) {
+  const code = span.status.code;
+  const label = statusLabelMap[code] ?? "UNSET";
+  const colorFn = statusColorMap[code] ?? colors.gray;
+  return colorFn(label).padEnd(6);
+}
+function formatDuration(span, offsetMs) {
+  const duration = calculateDuration(span);
+  const format = (ms) => ms >= 1e3 ? `${(ms / 1e3).toFixed(2)} s` : `${ms} ms`;
+  return `${format(offsetMs || 0)}\u2013${format(duration)}`;
+}
+function truncate(input, maxLength) {
+  const str = String(input ?? "");
+  return str.length > maxLength ? `${str.slice(0, maxLength - 1)}\u2026` : str;
+}
+function computeDepth(span, allSpans) {
+  let depth = 0;
+  let currentParentId = span.parentSpanContext?.spanId;
+  while (currentParentId) {
+    const parentSpan = allSpans.find(
+      (s) => s.spanContext().spanId === currentParentId
+    );
+    if (!parentSpan) break;
+    depth += 1;
+    currentParentId = parentSpan.parentSpanContext?.spanId;
+  }
+  return depth;
+}
+
+// src/loggers/console-log-pretty-exporter.ts
+var ConsoleLogPrettyExporter = class {
+  logThreshold;
+  constructor() {
+    const defaultLogLevel = "INFO";
+    const env = process.env.LOG_LEVEL?.toUpperCase() ?? defaultLogLevel;
+    this.logThreshold = LOG_SEVERITY_MAP[env] ?? LOG_SEVERITY_MAP[defaultLogLevel];
+  }
+  export(logs3, resultCallback) {
+    this._sendLogRecords(logs3, resultCallback);
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+  _sendLogRecords(logRecords, done) {
+    for (const record of logRecords) {
+      if ((record.severityNumber ?? 0) >= this.logThreshold) {
+        console.log(formatLogRecord(record));
+      }
+    }
+    done?.({ code: ExportResultCode.SUCCESS });
+  }
+};
+
+// src/loggers/console-span-pretty-exporter.ts
+import { SpanStatusCode as SpanStatusCode2 } from "@opentelemetry/api";
+import { ExportResultCode as ExportResultCode2 } from "@opentelemetry/core";
+var ConsoleSpanPrettyExporter = class {
+  allowedStatuses;
+  constructor() {
+    const env = process.env.SPAN_LEVEL?.toUpperCase();
+    if (!env) {
+      this.allowedStatuses = /* @__PURE__ */ new Set([
+        SpanStatusCode2.UNSET,
+        SpanStatusCode2.OK,
+        SpanStatusCode2.ERROR
+      ]);
+    } else {
+      const map = {
+        UNSET: SpanStatusCode2.UNSET,
+        OK: SpanStatusCode2.OK,
+        ERROR: SpanStatusCode2.ERROR
+      };
+      this.allowedStatuses = new Set(
+        env.split(",").map((s) => s.trim()).map((s) => map[s]).filter((v) => typeof v === "number")
+      );
+    }
+  }
+  shouldExport(spans) {
+    if (this.allowedStatuses.size === 3) {
+      return true;
+    }
+    return spans.some((span) => this.allowedStatuses.has(span.status.code));
+  }
+  export(spans, resultCallback) {
+    if (this.shouldExport(spans)) {
+      console.log(formatSpans(spans));
+    }
+    resultCallback({ code: ExportResultCode2.SUCCESS });
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+};
+
+// src/loggers/console-metric-pretty-exporter.ts
+import { ExportResultCode as ExportResultCode3 } from "@opentelemetry/core";
+var ConsoleMetricPrettyExporter = class {
+  patterns;
+  constructor() {
+    const raw = process.env.METRIC_FILTER ?? "";
+    const entries = raw.split(",").map((e) => e.trim()).filter(Boolean);
+    this.patterns = entries.map(globToRegex);
+  }
+  filterMetrics(resourceMetrics) {
+    if (this.patterns.length === 0) return void 0;
+    const filteredScopes = resourceMetrics.scopeMetrics.map((scopeMetric) => {
+      const filteredMetrics = scopeMetric.metrics.filter(
+        (metric) => this.patterns.some((pattern) => pattern.test(metric.descriptor.name))
+      );
+      if (filteredMetrics.length === 0) return void 0;
+      return {
+        ...scopeMetric,
+        metrics: filteredMetrics
+      };
+    }).filter((s) => s !== void 0);
+    if (filteredScopes.length === 0) return void 0;
+    return {
+      ...resourceMetrics,
+      scopeMetrics: filteredScopes
+    };
+  }
+  export(metrics2, resultCallback) {
+    const filtered = this.filterMetrics(metrics2);
+    if (filtered) {
+      console.log(formatMetrics(filtered));
+    }
+    resultCallback({ code: ExportResultCode3.SUCCESS });
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+};
+function globToRegex(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const regex = `^${escaped.replace(/\*/g, ".*")}$`;
+  return new RegExp(regex);
+}
+
+// src/loggers/tree-span-processor.ts
+var TreeSpanProcessor = class {
+  exporter;
+  orphans = /* @__PURE__ */ new Map();
+  constructor(exporter) {
+    this.exporter = exporter;
+  }
+  onStart() {
+  }
+  onEnd(span) {
+    const parentId = span.parentSpanContext?.spanId;
+    if (parentId) {
+      const siblings = this.orphans.get(parentId) || [];
+      this.orphans.set(parentId, [...siblings, span]);
+      return;
+    }
+    const children = this.getChildrenRecursively(span);
+    const sorted = [span, ...children].sort((s1, s2) => {
+      const [sec1, nano1] = s1.startTime;
+      const [sec2, nano2] = s2.startTime;
+      if (sec1 !== sec2) return sec1 - sec2;
+      return nano1 - nano2;
     });
-    await sdk.start();
-    console.log(`[otel] Telemetry initialized for "${serviceName}"`);
-    process.on("SIGTERM", async () => {
-      console.log("[otel] Shutting down...");
-      await Promise.all([sdk.shutdown(), logProvider.shutdown()]);
-      console.log("[otel] Shutdown complete.");
-      process.exit(0);
+    this.exporter.export(sorted, () => {
     });
-  } catch (err) {
-    console.error("[otel] Startup error:", err);
   }
-}
-initialize();
+  getChildrenRecursively(span) {
+    const spanId = span.spanContext().spanId;
+    const children = this.orphans.get(spanId) || [];
+    this.orphans.delete(spanId);
+    const result = [...children];
+    for (const child of children) {
+      result.push(...this.getChildrenRecursively(child));
+    }
+    return result;
+  }
+  shutdown() {
+    return this.exporter.shutdown();
+  }
+  async forceFlush() {
+    await this.exporter.forceFlush?.();
+  }
+};
 
-// src/logger.ts
-import { context, trace } from "@opentelemetry/api";
-import { logs as logs2 } from "@opentelemetry/api-logs";
+// src/providers.ts
+var getLogProvider = (resource, otlpEndpoint) => {
+  const exporter = otlpEndpoint ? new OTLPLogExporter({ url: `${otlpEndpoint}/v1/logs` }) : new ConsoleLogPrettyExporter();
+  const processor = otlpEndpoint ? new BatchLogRecordProcessor(exporter) : new SimpleLogRecordProcessor(exporter);
+  const provider = new LoggerProvider({
+    resource,
+    processors: [processor]
+  });
+  return provider;
+};
+var getSpanProcessor = (otlpEndpoint) => {
+  const exporter = otlpEndpoint ? new OTLPTraceExporter({
+    url: `${otlpEndpoint}/v1/traces`
+  }) : new ConsoleSpanPrettyExporter();
+  const processor = otlpEndpoint ? new BatchSpanProcessor(exporter) : new TreeSpanProcessor(exporter);
+  return processor;
+};
+var getMetricReader = (otlpEndpoint) => {
+  const metricExporter = otlpEndpoint ? new OTLPMetricExporter({
+    url: `${otlpEndpoint}/v1/metrics`
+  }) : new ConsoleMetricPrettyExporter();
+  const metricReader = new PeriodicExportingMetricReader({
+    exporter: metricExporter
+  });
+  return metricReader;
+};
+
+// src/resource.ts
+import {
+  detectResources,
+  resourceFromAttributes
+} from "@opentelemetry/resources";
 
 // src/otel-context.ts
-function detectTelemetryContext(serviceOverride) {
+import {
+  ATTR_SERVICE_NAME as ATTR_SERVICE_NAME2,
+  ATTR_SERVICE_VERSION as ATTR_SERVICE_VERSION2
+} from "@opentelemetry/semantic-conventions";
+function detectTelemetryContext(componentNameOverride) {
   const {
     OTEL_SERVICE_NAME,
+    // e.g. "UserSystem"
     OTEL_SERVICE_VERSION,
+    // e.g. "1.2.3"
     K_SERVICE,
     K_REVISION,
     K_CONFIGURATION,
@@ -83,13 +565,14 @@ function detectTelemetryContext(serviceOverride) {
     GCP_PROJECT,
     CLOUD_PROVIDER
   } = process.env;
-  const serviceName2 = serviceOverride || OTEL_SERVICE_NAME || "unknown-service";
-  const serviceVersion = OTEL_SERVICE_VERSION || "1.0.0";
+  const systemName = OTEL_SERVICE_NAME || "unknown-service";
+  const systemVersion = OTEL_SERVICE_VERSION || "1.0.0";
+  const componentName = componentNameOverride || void 0;
   const resourceAttributes = {
-    "service.name": serviceName2,
-    "service.version": serviceVersion,
-    "serviceContext.service": serviceName2,
-    "serviceContext.version": serviceVersion,
+    [ATTR_SERVICE_NAME2]: systemName,
+    [ATTR_SERVICE_VERSION2]: systemVersion,
+    "serviceContext.service": systemName,
+    "serviceContext.version": systemVersion,
     ...K_SERVICE && { "cloud.run.service": K_SERVICE },
     ...K_REVISION && { "cloud.run.revision": K_REVISION },
     ...K_CONFIGURATION && { "cloud.run.configuration": K_CONFIGURATION },
@@ -97,28 +580,75 @@ function detectTelemetryContext(serviceOverride) {
     ...POD_NAMESPACE && { "k8s.namespace_name": POD_NAMESPACE },
     ...KUBERNETES_SERVICE_HOST && { "cloud.orchestrator": "kubernetes" },
     ...GCP_PROJECT && { "cloud.account.id": GCP_PROJECT },
-    ...CLOUD_PROVIDER && { "cloud.provider": CLOUD_PROVIDER }
+    ...CLOUD_PROVIDER && { "cloud.provider": CLOUD_PROVIDER },
+    ...componentName && { "component.name": componentName }
   };
   return {
-    serviceName: serviceName2,
-    serviceVersion,
+    systemName,
+    systemVersion,
+    componentName,
     resourceAttributes
   };
 }
 
+// src/resource.ts
+var getResource = async () => {
+  const baseRes = await detectResources();
+  const { resourceAttributes } = detectTelemetryContext();
+  const customRes = resourceFromAttributes(resourceAttributes);
+  const resource = baseRes.merge(customRes);
+  return resource;
+};
+
+// src/otel.ts
+diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.ERROR);
+async function initialize() {
+  try {
+    const serviceName = process.env.OTEL_SERVICE_NAME ?? "unknown-service";
+    const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+    const resource = await getResource();
+    context.setGlobalContextManager(
+      new AsyncLocalStorageContextManager().enable()
+    );
+    const logProvider = getLogProvider(resource, otlpEndpoint);
+    logs.setGlobalLoggerProvider(logProvider);
+    const spanProcessor = getSpanProcessor(otlpEndpoint);
+    const metricReader = getMetricReader(otlpEndpoint);
+    const sdk = new NodeSDK({
+      spanProcessor,
+      metricReader,
+      instrumentations: [getNodeAutoInstrumentations()],
+      resource
+    });
+    await sdk.start();
+    console.log(`[otel] Telemetry initialized for "${serviceName}"`);
+    process.on("SIGTERM", async () => {
+      console.log("[otel] Shutting down...");
+      await Promise.all([sdk.shutdown(), logProvider.shutdown()]);
+      console.log("[otel] Shutdown complete.");
+      process.exit(0);
+    });
+  } catch (err) {
+    console.error("[otel] Startup error:", err);
+  }
+}
+
 // src/logger.ts
+import { context as context2, trace } from "@opentelemetry/api";
+import { logs as logs2 } from "@opentelemetry/api-logs";
 function getLogger(serviceOverride, extraAttrs = {}) {
-  const { serviceName: serviceName2, serviceVersion, resourceAttributes } = detectTelemetryContext(serviceOverride);
-  const logger = logs2.getLogger(serviceName2, serviceVersion, {});
+  const { systemName, systemVersion, resourceAttributes } = detectTelemetryContext(serviceOverride);
+  const logger = logs2.getLogger(systemName, systemVersion);
   const defaultAttrs = {
     ...resourceAttributes,
     ...extraAttrs
   };
   function emit(severityText, body, attrs = {}) {
-    const span = trace.getSpan(context.active());
+    const span = trace.getSpan(context2.active());
     const spanContext = span?.spanContext();
     logger.emit({
       severityText,
+      severityNumber: LOG_SEVERITY_MAP[severityText],
       body,
       attributes: {
         ...defaultAttrs,
@@ -147,33 +677,43 @@ function getLogger(serviceOverride, extraAttrs = {}) {
 
 // src/metrics.ts
 import { metrics } from "@opentelemetry/api";
-function getMeter(serviceOverride) {
-  const { serviceName: serviceName2 } = detectTelemetryContext(serviceOverride);
-  return metrics.getMeter(serviceName2);
+function getMeter(componentNameOverride) {
+  const { componentName, systemName, systemVersion } = detectTelemetryContext(
+    componentNameOverride
+  );
+  return metrics.getMeter(componentName ?? systemName, systemVersion);
 }
 
 // src/tracer.ts
 import {
-  context as context2,
-  SpanStatusCode,
+  context as context3,
+  SpanStatusCode as SpanStatusCode3,
   trace as trace2
 } from "@opentelemetry/api";
-function getTracer(serviceOverride) {
-  const { serviceName: serviceName2 } = detectTelemetryContext(serviceOverride);
-  const tracer = trace2.getTracer(serviceName2);
-  const withTrace = async (name, optionsOrFn, maybeFn) => {
-    const options = typeof maybeFn === "function" ? optionsOrFn : {};
-    const fn = typeof maybeFn === "function" ? maybeFn : optionsOrFn;
-    const ctx = context2.active();
-    const span = tracer.startSpan(name, options, ctx);
-    return await context2.with(trace2.setSpan(ctx, span), async () => {
+function getTracer(componentNameOverride) {
+  const { componentName, systemName, systemVersion } = detectTelemetryContext(
+    componentNameOverride
+  );
+  const tracer = trace2.getTracer(
+    componentName ?? systemName,
+    systemVersion
+  );
+  const withTrace = async (name, spanOptionsSpanOrFunc, spanOrFunc, func) => {
+    const { options, parent, fn } = extractArgs(
+      spanOptionsSpanOrFunc,
+      spanOrFunc,
+      func
+    );
+    const parentContext = parent ? trace2.setSpan(context3.active(), parent) : context3.active();
+    const span = tracer.startSpan(name, options, parentContext);
+    return await context3.with(trace2.setSpan(parentContext, span), async () => {
       try {
         const result = await fn(span);
-        span.setStatus({ code: SpanStatusCode.OK });
+        span.setStatus({ code: SpanStatusCode3.OK });
         return result;
       } catch (err) {
         const error = err;
-        span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+        span.setStatus({ code: SpanStatusCode3.ERROR, message: error.message });
         span.recordException?.(error);
         throw err;
       } finally {
@@ -181,19 +721,22 @@ function getTracer(serviceOverride) {
       }
     });
   };
-  const withTraceSync = (name, optionsOrFn, maybeFn) => {
-    const options = typeof maybeFn === "function" ? optionsOrFn : {};
-    const fn = typeof maybeFn === "function" ? maybeFn : optionsOrFn;
-    const ctx = context2.active();
-    const span = tracer.startSpan(name, options, ctx);
-    return context2.with(trace2.setSpan(ctx, span), () => {
+  const withTraceSync = (name, spanOptionsSpanOrFunc, spanOrFunc, func) => {
+    const { options, parent, fn } = extractArgs(
+      spanOptionsSpanOrFunc,
+      spanOrFunc,
+      func
+    );
+    const parentContext = parent ? trace2.setSpan(context3.active(), parent) : context3.active();
+    const span = tracer.startSpan(name, options, parentContext);
+    return context3.with(trace2.setSpan(parentContext, span), () => {
       try {
         const result = fn(span);
-        span.setStatus({ code: SpanStatusCode.OK });
+        span.setStatus({ code: SpanStatusCode3.OK });
         return result;
       } catch (err) {
         const error = err;
-        span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+        span.setStatus({ code: SpanStatusCode3.ERROR, message: error.message });
         span.recordException?.(error);
         throw err;
       } finally {
@@ -205,6 +748,30 @@ function getTracer(serviceOverride) {
   tracer.withTraceSync = withTraceSync;
   return tracer;
 }
+function extractArgs(spanOptionsSpanOrFunc, spanOrFunc, func) {
+  let options = {};
+  let parent;
+  let fn;
+  if (typeof spanOptionsSpanOrFunc === "function") {
+    fn = spanOptionsSpanOrFunc;
+  } else if (typeof spanOrFunc === "function") {
+    const spanOrSpanOptions = spanOptionsSpanOrFunc;
+    if ("startTime" in spanOrSpanOptions || "attributes" in spanOrSpanOptions || "kind" in spanOrSpanOptions) {
+      options = spanOrSpanOptions;
+    } else {
+      parent = spanOrSpanOptions;
+    }
+    fn = spanOrFunc;
+  } else {
+    options = spanOptionsSpanOrFunc;
+    parent = spanOrFunc;
+    fn = func;
+  }
+  return { options, parent, fn };
+}
+
+// src/index.ts
+initialize();
 export {
   getLogger,
   getMeter,