tracebeam-sdk 0.2.0 → 0.4.0

package/dist/index.d.mts

@@ -1,5 +1,7 @@
-import { T as TraceBeamConfig } from './sdk-bh44OWR9.mjs';
-export { C as CaptureOptions, d as Event, e as EventBatch, E as EventLevel, c as Extra, b as Tags, a as TraceBeamSDK, g as TransportErrorResponse, h as TransportResponse, f as TransportSuccessResponse } from './sdk-bh44OWR9.mjs';
+import { T as TraceBeamConfig } from './sdk-PSGN9S91.mjs';
+export { C as CaptureOptions, d as Event, e as EventBatch, E as EventLevel, c as Extra, b as Tags, a as TraceBeamSDK, g as TransportErrorResponse, h as TransportResponse, f as TransportSuccessResponse } from './sdk-PSGN9S91.mjs';
+import { MeterProvider, Histogram, Counter, UpDownCounter } from '@opentelemetry/api';
+import '@opentelemetry/sdk-metrics';
 
 /**
  * Default configuration values
@@ -33,4 +35,37 @@ declare function mergeConfig(config: TraceBeamConfig): Required<TraceBeamConfig>
  */
 declare function validateConfig(config: TraceBeamConfig): void;
 
-export { ConfigError, DEFAULT_CONFIG, TraceBeamConfig, loadConfigFromEnv, mergeConfig, validateConfig };
+/**
+ * HTTP metrics for request tracking
+ * All metrics are non-blocking and use OTLP semantic conventions
+ */
+interface HttpMetrics {
+    /** Request duration histogram */
+    duration: Histogram;
+    /** Total request count */
+    requestCount: Counter;
+    /** Error count (5xx responses) */
+    errorCount: Counter;
+    /** Currently active requests */
+    activeRequests: UpDownCounter;
+}
+/**
+ * Create HTTP metrics instruments
+ */
+declare function createHttpMetrics(meterProvider: MeterProvider, prefix?: string): HttpMetrics;
+/**
+ * Common attributes for HTTP metrics
+ */
+interface HttpMetricAttributes {
+    'http.method': string;
+    'http.route': string;
+    'http.status_code': number;
+    'http.scheme'?: string;
+    'net.host.name'?: string;
+}
+/**
+ * Record HTTP request metrics (call at request end)
+ */
+declare function recordHttpRequest(metrics: HttpMetrics, durationMs: number, attributes: HttpMetricAttributes): void;
+
+export { ConfigError, DEFAULT_CONFIG, type HttpMetricAttributes, type HttpMetrics, TraceBeamConfig, createHttpMetrics, loadConfigFromEnv, mergeConfig, recordHttpRequest, validateConfig };

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-import { T as TraceBeamConfig } from './sdk-bh44OWR9.js';
-export { C as CaptureOptions, d as Event, e as EventBatch, E as EventLevel, c as Extra, b as Tags, a as TraceBeamSDK, g as TransportErrorResponse, h as TransportResponse, f as TransportSuccessResponse } from './sdk-bh44OWR9.js';
+import { T as TraceBeamConfig } from './sdk-PSGN9S91.js';
+export { C as CaptureOptions, d as Event, e as EventBatch, E as EventLevel, c as Extra, b as Tags, a as TraceBeamSDK, g as TransportErrorResponse, h as TransportResponse, f as TransportSuccessResponse } from './sdk-PSGN9S91.js';
+import { MeterProvider, Histogram, Counter, UpDownCounter } from '@opentelemetry/api';
+import '@opentelemetry/sdk-metrics';
 
 /**
  * Default configuration values
@@ -33,4 +35,37 @@ declare function mergeConfig(config: TraceBeamConfig): Required<TraceBeamConfig>
  */
 declare function validateConfig(config: TraceBeamConfig): void;
 
-export { ConfigError, DEFAULT_CONFIG, TraceBeamConfig, loadConfigFromEnv, mergeConfig, validateConfig };
+/**
+ * HTTP metrics for request tracking
+ * All metrics are non-blocking and use OTLP semantic conventions
+ */
+interface HttpMetrics {
+    /** Request duration histogram */
+    duration: Histogram;
+    /** Total request count */
+    requestCount: Counter;
+    /** Error count (5xx responses) */
+    errorCount: Counter;
+    /** Currently active requests */
+    activeRequests: UpDownCounter;
+}
+/**
+ * Create HTTP metrics instruments
+ */
+declare function createHttpMetrics(meterProvider: MeterProvider, prefix?: string): HttpMetrics;
+/**
+ * Common attributes for HTTP metrics
+ */
+interface HttpMetricAttributes {
+    'http.method': string;
+    'http.route': string;
+    'http.status_code': number;
+    'http.scheme'?: string;
+    'net.host.name'?: string;
+}
+/**
+ * Record HTTP request metrics (call at request end)
+ */
+declare function recordHttpRequest(metrics: HttpMetrics, durationMs: number, attributes: HttpMetricAttributes): void;
+
+export { ConfigError, DEFAULT_CONFIG, type HttpMetricAttributes, type HttpMetrics, TraceBeamConfig, createHttpMetrics, loadConfigFromEnv, mergeConfig, recordHttpRequest, validateConfig };

package/dist/index.js

@@ -33,8 +33,10 @@ __export(src_exports, {
   ConfigError: () => ConfigError,
   DEFAULT_CONFIG: () => DEFAULT_CONFIG,
   TraceBeamSDK: () => TraceBeamSDK,
+  createHttpMetrics: () => createHttpMetrics,
   loadConfigFromEnv: () => loadConfigFromEnv,
   mergeConfig: () => mergeConfig,
+  recordHttpRequest: () => recordHttpRequest,
   validateConfig: () => validateConfig
 });
 module.exports = __toCommonJS(src_exports);
@@ -473,6 +475,8 @@ var SimpleSpanProcessor = class {
 // src/sdk.ts
 var import_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
 var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
+var import_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
 var import_resources = require("@opentelemetry/resources");
 var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
 
@@ -749,10 +753,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 = {};
@@ -765,39 +894,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 import_exporter_trace_otlp_http.OTLPTraceExporter({
-      url: exporterUrl,
+    const traceExporterUrl = `${baseUrl}/v1/traces`;
+    const metricExporterUrl = `${baseUrl}/v1/metrics`;
+    const traceExporter = new import_exporter_trace_otlp_http.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 = (0, import_resources.resourceFromAttributes)({
+      [import_semantic_conventions.SemanticResourceAttributes.SERVICE_NAME]: this.config.projectId,
+      [import_semantic_conventions.SemanticResourceAttributes.SERVICE_VERSION]: this.config.environment,
+      [import_semantic_conventions.SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: this.config.environment,
+      "telemetry.sdk.language": "nodejs",
+      "telemetry.sdk.name": "tracebeam-sdk",
+      "telemetry.sdk.version": "0.2.1"
+    });
     this.provider = new import_sdk_trace_node.NodeTracerProvider({
-      resource: (0, import_resources.resourceFromAttributes)({
-        [import_semantic_conventions.SemanticResourceAttributes.SERVICE_NAME]: this.config.projectId,
-        [import_semantic_conventions.SemanticResourceAttributes.SERVICE_VERSION]: this.config.environment,
-        [import_semantic_conventions.SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: this.config.environment,
-        "telemetry.sdk.language": "nodejs",
-        "telemetry.sdk.name": "tracebeam-sdk",
-        "telemetry.sdk.version": "0.2.0"
-      }),
+      resource,
       spanProcessors
     });
     this.provider.register();
+    const metricExporter = new import_exporter_metrics_otlp_http.OTLPMetricExporter({
+      url: metricExporterUrl,
+      headers: {
+        "Authorization": `Bearer ${this.config.apiKey}`
+      }
+    });
+    this.meterProvider = new import_sdk_metrics.MeterProvider({
+      resource,
+      readers: [
+        new import_sdk_metrics.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: [
         (0, import_auto_instrumentations_node.getNodeAutoInstrumentations)({
           // Disable some noisy instrumentations
@@ -812,6 +967,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
    */
@@ -908,10 +1075,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;
@@ -931,8 +1100,10 @@ var TraceBeamSDK = class _TraceBeamSDK {
   ConfigError,
   DEFAULT_CONFIG,
   TraceBeamSDK,
+  createHttpMetrics,
   loadConfigFromEnv,
   mergeConfig,
+  recordHttpRequest,
   validateConfig
 });
 //# sourceMappingURL=index.js.map