tracebeam-sdk 0.2.1 → 0.4.0

package/dist/index.mjs

@@ -432,6 +432,8 @@ var SimpleSpanProcessor = class {
 // src/sdk.ts
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions";
 
@@ -708,10 +710,135 @@ function parseBoolEnv(name, defaultValue) {
   return value.toLowerCase() === "true" || value === "1";
 }
 
+// src/metrics/runtime.ts
+function registerRuntimeMetrics(meterProvider) {
+  const meter = meterProvider.getMeter("tracebeam-runtime");
+  const memoryUsage = meter.createObservableGauge("process.runtime.nodejs.memory.heap_used", {
+    description: "Heap memory used in bytes",
+    unit: "By"
+  });
+  const memoryTotal = meter.createObservableGauge("process.runtime.nodejs.memory.heap_total", {
+    description: "Total heap memory in bytes",
+    unit: "By"
+  });
+  const memoryRss = meter.createObservableGauge("process.runtime.nodejs.memory.rss", {
+    description: "Resident set size in bytes",
+    unit: "By"
+  });
+  const memoryExternal = meter.createObservableGauge("process.runtime.nodejs.memory.external", {
+    description: "External memory in bytes",
+    unit: "By"
+  });
+  meter.addBatchObservableCallback(
+    (observableResult) => {
+      const mem = process.memoryUsage();
+      observableResult.observe(memoryUsage, mem.heapUsed);
+      observableResult.observe(memoryTotal, mem.heapTotal);
+      observableResult.observe(memoryRss, mem.rss);
+      observableResult.observe(memoryExternal, mem.external);
+    },
+    [memoryUsage, memoryTotal, memoryRss, memoryExternal]
+  );
+  const cpuUser = meter.createObservableGauge("process.runtime.nodejs.cpu.user", {
+    description: "CPU user time in microseconds",
+    unit: "us"
+  });
+  const cpuSystem = meter.createObservableGauge("process.runtime.nodejs.cpu.system", {
+    description: "CPU system time in microseconds",
+    unit: "us"
+  });
+  meter.addBatchObservableCallback(
+    (observableResult) => {
+      const cpu = process.cpuUsage();
+      observableResult.observe(cpuUser, cpu.user);
+      observableResult.observe(cpuSystem, cpu.system);
+    },
+    [cpuUser, cpuSystem]
+  );
+  const eventLoopLag = meter.createObservableGauge("process.runtime.nodejs.event_loop.lag", {
+    description: "Event loop lag in milliseconds",
+    unit: "ms"
+  });
+  let lastCheck = process.hrtime.bigint();
+  let currentLag = 0;
+  const measureLag = () => {
+    const now = process.hrtime.bigint();
+    const expected = 1000n;
+    const actual = Number(now - lastCheck) / 1e6;
+    currentLag = Math.max(0, actual - 1);
+    lastCheck = now;
+    setImmediate(measureLag);
+  };
+  setImmediate(measureLag);
+  eventLoopLag.addCallback((observableResult) => {
+    observableResult.observe(currentLag);
+  });
+  const activeHandles = meter.createObservableGauge("process.runtime.nodejs.active_handles", {
+    description: "Number of active handles",
+    unit: "{handles}"
+  });
+  const activeRequests = meter.createObservableGauge("process.runtime.nodejs.active_requests", {
+    description: "Number of active requests",
+    unit: "{requests}"
+  });
+  meter.addBatchObservableCallback(
+    (observableResult) => {
+      const handles = process._getActiveHandles?.()?.length ?? 0;
+      const requests = process._getActiveRequests?.()?.length ?? 0;
+      observableResult.observe(activeHandles, handles);
+      observableResult.observe(activeRequests, requests);
+    },
+    [activeHandles, activeRequests]
+  );
+  const uptime = meter.createObservableGauge("process.runtime.nodejs.uptime", {
+    description: "Process uptime in seconds",
+    unit: "s"
+  });
+  uptime.addCallback((observableResult) => {
+    observableResult.observe(process.uptime());
+  });
+}
+
+// src/metrics/http.ts
+function createHttpMetrics(meterProvider, prefix = "http.server") {
+  const meter = meterProvider.getMeter("tracebeam-http");
+  return {
+    duration: meter.createHistogram(`${prefix}.request.duration`, {
+      description: "Duration of HTTP requests",
+      unit: "ms"
+    }),
+    requestCount: meter.createCounter(`${prefix}.request.count`, {
+      description: "Total number of HTTP requests",
+      unit: "{requests}"
+    }),
+    errorCount: meter.createCounter(`${prefix}.error.count`, {
+      description: "Total number of HTTP errors (5xx)",
+      unit: "{errors}"
+    }),
+    activeRequests: meter.createUpDownCounter(`${prefix}.active_requests`, {
+      description: "Number of active HTTP requests",
+      unit: "{requests}"
+    })
+  };
+}
+function recordHttpRequest(metrics3, durationMs, attributes) {
+  const labels = {
+    "http.method": attributes["http.method"],
+    "http.route": attributes["http.route"],
+    "http.status_code": String(attributes["http.status_code"])
+  };
+  metrics3.duration.record(durationMs, labels);
+  metrics3.requestCount.add(1, labels);
+  if (attributes["http.status_code"] >= 500) {
+    metrics3.errorCount.add(1, labels);
+  }
+}
+
 // src/sdk.ts
 var TraceBeamSDK = class _TraceBeamSDK {
   config;
   provider;
+  meterProvider;
   tracer;
   isInitialized = true;
   globalTags = {};
@@ -724,39 +851,65 @@ var TraceBeamSDK = class _TraceBeamSDK {
     validateConfig(config);
     this.config = mergeConfig(config);
     const baseUrl = this.config.endpoint.replace(/\/$/, "");
-    const exporterUrl = `${baseUrl}/v1/traces`;
-    const exporter = new OTLPTraceExporter({
-      url: exporterUrl,
+    const traceExporterUrl = `${baseUrl}/v1/traces`;
+    const metricExporterUrl = `${baseUrl}/v1/metrics`;
+    const traceExporter = new OTLPTraceExporter({
+      url: traceExporterUrl,
       headers: {
         "Authorization": `Bearer ${this.config.apiKey}`
       }
     });
     const spanProcessors = [];
-    spanProcessors.push(new BatchSpanProcessor(exporter, {
+    spanProcessors.push(new BatchSpanProcessor(traceExporter, {
       maxExportBatchSize: this.config.batchSize,
       scheduledDelayMillis: this.config.flushInterval
     }));
     if (this.config.debug) {
       spanProcessors.push(new SimpleSpanProcessor(new ConsoleSpanExporter()));
-      console.debug("[tracebeam] Initialized OTLP", {
-        url: exporterUrl,
+      console.debug("[tracebeam] Initialized OTLP Traces", {
+        url: traceExporterUrl,
         projectId: this.config.projectId
       });
     }
+    const resource = resourceFromAttributes({
+      [SemanticResourceAttributes.SERVICE_NAME]: this.config.projectId,
+      [SemanticResourceAttributes.SERVICE_VERSION]: this.config.environment,
+      [SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: this.config.environment,
+      "telemetry.sdk.language": "nodejs",
+      "telemetry.sdk.name": "tracebeam-sdk",
+      "telemetry.sdk.version": "0.2.1"
+    });
     this.provider = new NodeTracerProvider({
-      resource: resourceFromAttributes({
-        [SemanticResourceAttributes.SERVICE_NAME]: this.config.projectId,
-        [SemanticResourceAttributes.SERVICE_VERSION]: this.config.environment,
-        [SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: this.config.environment,
-        "telemetry.sdk.language": "nodejs",
-        "telemetry.sdk.name": "tracebeam-sdk",
-        "telemetry.sdk.version": "0.2.1"
-      }),
+      resource,
       spanProcessors
     });
     this.provider.register();
+    const metricExporter = new OTLPMetricExporter({
+      url: metricExporterUrl,
+      headers: {
+        "Authorization": `Bearer ${this.config.apiKey}`
+      }
+    });
+    this.meterProvider = new MeterProvider({
+      resource,
+      readers: [
+        new PeriodicExportingMetricReader({
+          exporter: metricExporter,
+          exportIntervalMillis: this.config.flushInterval
+          // Match config
+        })
+      ]
+    });
+    api.metrics.setGlobalMeterProvider(this.meterProvider);
+    registerRuntimeMetrics(this.meterProvider);
+    if (this.config.debug) {
+      console.debug("[tracebeam] Initialized OTLP Metrics with runtime metrics", {
+        url: metricExporterUrl
+      });
+    }
     registerInstrumentations({
       tracerProvider: this.provider,
+      meterProvider: this.meterProvider,
       instrumentations: [
         getNodeAutoInstrumentations({
           // Disable some noisy instrumentations
@@ -771,6 +924,18 @@ var TraceBeamSDK = class _TraceBeamSDK {
     const config = loadConfigFromEnv();
     return new _TraceBeamSDK(config);
   }
+  /**
+   * Get the OpenTelemetry Meter for creating custom metrics
+   */
+  getMeter(name, version) {
+    return this.meterProvider.getMeter(name, version);
+  }
+  /**
+   * Get the MeterProvider for advanced metric creation
+   */
+  getMeterProvider() {
+    return this.meterProvider;
+  }
   /**
    * Capture an exception/error
    */
@@ -867,10 +1032,12 @@ var TraceBeamSDK = class _TraceBeamSDK {
   }
   async flush() {
     await this.provider.forceFlush();
+    await this.meterProvider.forceFlush();
   }
   async close() {
     this.isInitialized = false;
     await this.provider.shutdown();
+    await this.meterProvider.shutdown();
   }
   isActive() {
     return this.isInitialized;
@@ -889,8 +1056,10 @@ export {
   ConfigError,
   DEFAULT_CONFIG,
   TraceBeamSDK,
+  createHttpMetrics,
   loadConfigFromEnv,
   mergeConfig,
+  recordHttpRequest,
   validateConfig
 };
 //# sourceMappingURL=index.mjs.map