@sebspark/otel 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -27,72 +37,543 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/otel.ts
-var import_api = require("@opentelemetry/api");
+var import_api3 = require("@opentelemetry/api");
 var import_api_logs = require("@opentelemetry/api-logs");
 var import_auto_instrumentations_node = require("@opentelemetry/auto-instrumentations-node");
+var import_context_async_hooks = require("@opentelemetry/context-async-hooks");
+var import_sdk_node = require("@opentelemetry/sdk-node");
+
+// src/providers.ts
 var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
 var import_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
 var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
-var import_resources = require("@opentelemetry/resources");
 var import_sdk_logs = require("@opentelemetry/sdk-logs");
 var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
-var import_sdk_node = require("@opentelemetry/sdk-node");
+var import_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
+
+// src/loggers/console-log-pretty-exporter.ts
+var import_core = require("@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
 var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
-import_api.diag.setLogger(new import_api.DiagConsoleLogger(), import_api.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 import_exporter_trace_otlp_http.OTLPTraceExporter({
-  url: `${otlpEndpoint}/v1/traces`
-});
-var metricExporter = new import_exporter_metrics_otlp_http.OTLPMetricExporter({
-  url: `${otlpEndpoint}/v1/metrics`
-});
-var logExporter = new import_exporter_logs_otlp_http.OTLPLogExporter({ url: `${otlpEndpoint}/v1/logs` });
-var metricReader = new import_sdk_metrics.PeriodicExportingMetricReader({
-  exporter: metricExporter
-});
-async function initialize() {
-  try {
-    const baseRes = await (0, import_resources.detectResources)();
-    const customRes = (0, import_resources.resourceFromAttributes)({
-      [import_semantic_conventions.ATTR_SERVICE_NAME]: serviceName,
-      [import_semantic_conventions.ATTR_SERVICE_VERSION]: "1.0.0"
-    });
-    const resource = baseRes.merge(customRes);
-    const logProvider = new import_sdk_logs.LoggerProvider({
-      resource,
-      processors: [new import_sdk_logs.BatchLogRecordProcessor(logExporter)]
-    });
-    import_api_logs.logs.setGlobalLoggerProvider(logProvider);
-    const sdk = new import_sdk_node.NodeSDK({
-      traceExporter,
-      metricReader,
-      instrumentations: [(0, import_auto_instrumentations_node.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);
+var import_fast_safe_stringify = __toESM(require("fast-safe-stringify"));
+
+// src/loggers/formatters/style.ts
+var import_kleur = __toESM(require("kleur"));
+var colors = {
+  gray: import_kleur.default.gray,
+  dim: import_kleur.default.dim,
+  cyan: import_kleur.default.cyan,
+  white: import_kleur.default.white,
+  green: import_kleur.default.green,
+  yellow: import_kleur.default.yellow,
+  red: import_kleur.default.red,
+  magenta: import_kleur.default.magenta
+};
+var levelColorMap = {
+  DEBUG: import_kleur.default.magenta,
+  INFO: import_kleur.default.green,
+  WARN: import_kleur.default.yellow,
+  ERROR: import_kleur.default.red,
+  FATAL: import_kleur.default.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[import_semantic_conventions.ATTR_SERVICE_NAME] ?? "unknown-service";
+  const version = resource.attributes[import_semantic_conventions.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 : (0, import_fast_safe_stringify.default)(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" ? (0, import_fast_safe_stringify.default)(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";
 }
-initialize();
 
-// src/logger.ts
+// src/loggers/formatters/span.ts
+var import_api = require("@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 === import_api.SpanStatusCode.OK ? colors.green : span.status.code === import_api.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: import_core.ExportResultCode.SUCCESS });
+  }
+};
+
+// src/loggers/console-span-pretty-exporter.ts
 var import_api2 = require("@opentelemetry/api");
-var import_api_logs2 = require("@opentelemetry/api-logs");
+var import_core2 = require("@opentelemetry/core");
+var ConsoleSpanPrettyExporter = class {
+  allowedStatuses;
+  constructor() {
+    const env = process.env.SPAN_LEVEL?.toUpperCase();
+    if (!env) {
+      this.allowedStatuses = /* @__PURE__ */ new Set([
+        import_api2.SpanStatusCode.UNSET,
+        import_api2.SpanStatusCode.OK,
+        import_api2.SpanStatusCode.ERROR
+      ]);
+    } else {
+      const map = {
+        UNSET: import_api2.SpanStatusCode.UNSET,
+        OK: import_api2.SpanStatusCode.OK,
+        ERROR: import_api2.SpanStatusCode.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: import_core2.ExportResultCode.SUCCESS });
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+};
+
+// src/loggers/console-metric-pretty-exporter.ts
+var import_core3 = require("@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: import_core3.ExportResultCode.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;
+    });
+    this.exporter.export(sorted, () => {
+    });
+  }
+  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/providers.ts
+var getLogProvider = (resource, otlpEndpoint) => {
+  const exporter = otlpEndpoint ? new import_exporter_logs_otlp_http.OTLPLogExporter({ url: `${otlpEndpoint}/v1/logs` }) : new ConsoleLogPrettyExporter();
+  const processor = otlpEndpoint ? new import_sdk_logs.BatchLogRecordProcessor(exporter) : new import_sdk_logs.SimpleLogRecordProcessor(exporter);
+  const provider = new import_sdk_logs.LoggerProvider({
+    resource,
+    processors: [processor]
+  });
+  return provider;
+};
+var getSpanProcessor = (otlpEndpoint) => {
+  const exporter = otlpEndpoint ? new import_exporter_trace_otlp_http.OTLPTraceExporter({
+    url: `${otlpEndpoint}/v1/traces`
+  }) : new ConsoleSpanPrettyExporter();
+  const processor = otlpEndpoint ? new import_sdk_trace_node.BatchSpanProcessor(exporter) : new TreeSpanProcessor(exporter);
+  return processor;
+};
+var getMetricReader = (otlpEndpoint) => {
+  const metricExporter = otlpEndpoint ? new import_exporter_metrics_otlp_http.OTLPMetricExporter({
+    url: `${otlpEndpoint}/v1/metrics`
+  }) : new ConsoleMetricPrettyExporter();
+  const metricReader = new import_sdk_metrics.PeriodicExportingMetricReader({
+    exporter: metricExporter
+  });
+  return metricReader;
+};
+
+// src/resource.ts
+var import_resources = require("@opentelemetry/resources");
 
 // src/otel-context.ts
-function detectTelemetryContext(serviceOverride) {
+var import_semantic_conventions2 = require("@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,
@@ -102,13 +583,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,
+    [import_semantic_conventions2.ATTR_SERVICE_NAME]: systemName,
+    [import_semantic_conventions2.ATTR_SERVICE_VERSION]: 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 },
@@ -116,28 +598,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 (0, import_resources.detectResources)();
+  const { resourceAttributes } = detectTelemetryContext();
+  const customRes = (0, import_resources.resourceFromAttributes)(resourceAttributes);
+  const resource = baseRes.merge(customRes);
+  return resource;
+};
+
+// src/otel.ts
+import_api3.diag.setLogger(new import_api3.DiagConsoleLogger(), import_api3.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();
+    import_api3.context.setGlobalContextManager(
+      new import_context_async_hooks.AsyncLocalStorageContextManager().enable()
+    );
+    const logProvider = getLogProvider(resource, otlpEndpoint);
+    import_api_logs.logs.setGlobalLoggerProvider(logProvider);
+    const spanProcessor = getSpanProcessor(otlpEndpoint);
+    const metricReader = getMetricReader(otlpEndpoint);
+    const sdk = new import_sdk_node.NodeSDK({
+      spanProcessor,
+      metricReader,
+      instrumentations: [(0, import_auto_instrumentations_node.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
+var import_api4 = require("@opentelemetry/api");
+var import_api_logs2 = require("@opentelemetry/api-logs");
 function getLogger(serviceOverride, extraAttrs = {}) {
-  const { serviceName: serviceName2, serviceVersion, resourceAttributes } = detectTelemetryContext(serviceOverride);
-  const logger = import_api_logs2.logs.getLogger(serviceName2, serviceVersion, {});
+  const { systemName, systemVersion, resourceAttributes } = detectTelemetryContext(serviceOverride);
+  const logger = import_api_logs2.logs.getLogger(systemName, systemVersion);
   const defaultAttrs = {
     ...resourceAttributes,
     ...extraAttrs
   };
   function emit(severityText, body, attrs = {}) {
-    const span = import_api2.trace.getSpan(import_api2.context.active());
+    const span = import_api4.trace.getSpan(import_api4.context.active());
     const spanContext = span?.spanContext();
     logger.emit({
       severityText,
+      severityNumber: LOG_SEVERITY_MAP[severityText],
       body,
       attributes: {
         ...defaultAttrs,
@@ -165,30 +694,40 @@ function getLogger(serviceOverride, extraAttrs = {}) {
 }
 
 // src/metrics.ts
-var import_api3 = require("@opentelemetry/api");
-function getMeter(serviceOverride) {
-  const { serviceName: serviceName2 } = detectTelemetryContext(serviceOverride);
-  return import_api3.metrics.getMeter(serviceName2);
+var import_api5 = require("@opentelemetry/api");
+function getMeter(componentNameOverride) {
+  const { componentName, systemName, systemVersion } = detectTelemetryContext(
+    componentNameOverride
+  );
+  return import_api5.metrics.getMeter(componentName ?? systemName, systemVersion);
 }
 
 // src/tracer.ts
-var import_api4 = require("@opentelemetry/api");
-function getTracer(serviceOverride) {
-  const { serviceName: serviceName2 } = detectTelemetryContext(serviceOverride);
-  const tracer = import_api4.trace.getTracer(serviceName2);
-  const withTrace = async (name, optionsOrFn, maybeFn) => {
-    const options = typeof maybeFn === "function" ? optionsOrFn : {};
-    const fn = typeof maybeFn === "function" ? maybeFn : optionsOrFn;
-    const ctx = import_api4.context.active();
-    const span = tracer.startSpan(name, options, ctx);
-    return await import_api4.context.with(import_api4.trace.setSpan(ctx, span), async () => {
+var import_api6 = require("@opentelemetry/api");
+function getTracer(componentNameOverride) {
+  const { componentName, systemName, systemVersion } = detectTelemetryContext(
+    componentNameOverride
+  );
+  const tracer = import_api6.trace.getTracer(
+    componentName ?? systemName,
+    systemVersion
+  );
+  const withTrace = async (name, spanOptionsSpanOrFunc, spanOrFunc, func) => {
+    const { options, parent, fn } = extractArgs(
+      spanOptionsSpanOrFunc,
+      spanOrFunc,
+      func
+    );
+    const parentContext = parent ? import_api6.trace.setSpan(import_api6.context.active(), parent) : import_api6.context.active();
+    const span = tracer.startSpan(name, options, parentContext);
+    return await import_api6.context.with(import_api6.trace.setSpan(parentContext, span), async () => {
       try {
         const result = await fn(span);
-        span.setStatus({ code: import_api4.SpanStatusCode.OK });
+        span.setStatus({ code: import_api6.SpanStatusCode.OK });
         return result;
       } catch (err) {
         const error = err;
-        span.setStatus({ code: import_api4.SpanStatusCode.ERROR, message: error.message });
+        span.setStatus({ code: import_api6.SpanStatusCode.ERROR, message: error.message });
         span.recordException?.(error);
         throw err;
       } finally {
@@ -196,19 +735,22 @@ function getTracer(serviceOverride) {
       }
     });
   };
-  const withTraceSync = (name, optionsOrFn, maybeFn) => {
-    const options = typeof maybeFn === "function" ? optionsOrFn : {};
-    const fn = typeof maybeFn === "function" ? maybeFn : optionsOrFn;
-    const ctx = import_api4.context.active();
-    const span = tracer.startSpan(name, options, ctx);
-    return import_api4.context.with(import_api4.trace.setSpan(ctx, span), () => {
+  const withTraceSync = (name, spanOptionsSpanOrFunc, spanOrFunc, func) => {
+    const { options, parent, fn } = extractArgs(
+      spanOptionsSpanOrFunc,
+      spanOrFunc,
+      func
+    );
+    const parentContext = parent ? import_api6.trace.setSpan(import_api6.context.active(), parent) : import_api6.context.active();
+    const span = tracer.startSpan(name, options, parentContext);
+    return import_api6.context.with(import_api6.trace.setSpan(parentContext, span), () => {
       try {
         const result = fn(span);
-        span.setStatus({ code: import_api4.SpanStatusCode.OK });
+        span.setStatus({ code: import_api6.SpanStatusCode.OK });
         return result;
       } catch (err) {
         const error = err;
-        span.setStatus({ code: import_api4.SpanStatusCode.ERROR, message: error.message });
+        span.setStatus({ code: import_api6.SpanStatusCode.ERROR, message: error.message });
         span.recordException?.(error);
         throw err;
       } finally {
@@ -220,6 +762,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();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getLogger,