tracebeam-sdk 0.1.1 → 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
@@ -23,10 +33,622 @@ __export(src_exports, {
   ConfigError: () => ConfigError,
   DEFAULT_CONFIG: () => DEFAULT_CONFIG,
   TraceBeamSDK: () => TraceBeamSDK,
-  loadConfigFromEnv: () => loadConfigFromEnv
+  loadConfigFromEnv: () => loadConfigFromEnv,
+  mergeConfig: () => mergeConfig,
+  validateConfig: () => validateConfig
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/sdk.ts
+var api = __toESM(require("@opentelemetry/api"));
+
+// node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
+var import_api = require("@opentelemetry/api");
+var SUPPRESS_TRACING_KEY = (0, import_api.createContextKey)("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+function suppressTracing(context3) {
+  return context3.setValue(SUPPRESS_TRACING_KEY, true);
+}
+
+// node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js
+var import_api2 = require("@opentelemetry/api");
+function loggingErrorHandler() {
+  return (ex) => {
+    import_api2.diag.error(stringifyException(ex));
+  };
+}
+function stringifyException(ex) {
+  if (typeof ex === "string") {
+    return ex;
+  } else {
+    return JSON.stringify(flattenException(ex));
+  }
+}
+function flattenException(ex) {
+  const result = {};
+  let current = ex;
+  while (current !== null) {
+    Object.getOwnPropertyNames(current).forEach((propertyName) => {
+      if (result[propertyName])
+        return;
+      const value = current[propertyName];
+      if (value) {
+        result[propertyName] = String(value);
+      }
+    });
+    current = Object.getPrototypeOf(current);
+  }
+  return result;
+}
+
+// node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js
+var delegateHandler = loggingErrorHandler();
+function globalErrorHandler(ex) {
+  try {
+    delegateHandler(ex);
+  } catch {
+  }
+}
+
+// node_modules/@opentelemetry/core/build/esm/platform/node/environment.js
+var import_api3 = require("@opentelemetry/api");
+var import_util = require("util");
+function getNumberFromEnv(key) {
+  const raw = process.env[key];
+  if (raw == null || raw.trim() === "") {
+    return void 0;
+  }
+  const value = Number(raw);
+  if (isNaN(value)) {
+    import_api3.diag.warn(`Unknown value ${(0, import_util.inspect)(raw)} for ${key}, expected a number, using defaults`);
+    return void 0;
+  }
+  return value;
+}
+
+// node_modules/@opentelemetry/core/build/esm/common/time.js
+var NANOSECOND_DIGITS = 9;
+var NANOSECOND_DIGITS_IN_MILLIS = 6;
+var MILLISECONDS_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS_IN_MILLIS);
+var SECOND_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS);
+function hrTimeToMicroseconds(time) {
+  return time[0] * 1e6 + time[1] / 1e3;
+}
+
+// node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var ExportResultCode;
+(function(ExportResultCode2) {
+  ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
+  ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
+})(ExportResultCode || (ExportResultCode = {}));
+
+// node_modules/@opentelemetry/core/build/esm/utils/promise.js
+var Deferred = class {
+  _promise;
+  _resolve;
+  _reject;
+  constructor() {
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  get promise() {
+    return this._promise;
+  }
+  resolve(val) {
+    this._resolve(val);
+  }
+  reject(err) {
+    this._reject(err);
+  }
+};
+
+// node_modules/@opentelemetry/core/build/esm/utils/callback.js
+var BindOnceFuture = class {
+  _isCalled = false;
+  _deferred = new Deferred();
+  _callback;
+  _that;
+  constructor(callback, that) {
+    this._callback = callback;
+    this._that = that;
+  }
+  get isCalled() {
+    return this._isCalled;
+  }
+  get promise() {
+    return this._deferred.promise;
+  }
+  call(...args) {
+    if (!this._isCalled) {
+      this._isCalled = true;
+      try {
+        Promise.resolve(this._callback.call(this._that, ...args)).then((val) => this._deferred.resolve(val), (err) => this._deferred.reject(err));
+      } catch (err) {
+        this._deferred.reject(err);
+      }
+    }
+    return this._deferred.promise;
+  }
+};
+
+// node_modules/@opentelemetry/core/build/esm/internal/exporter.js
+var import_api4 = require("@opentelemetry/api");
+function _export(exporter, arg) {
+  return new Promise((resolve) => {
+    import_api4.context.with(suppressTracing(import_api4.context.active()), () => {
+      exporter.export(arg, (result) => {
+        resolve(result);
+      });
+    });
+  });
+}
+
+// node_modules/@opentelemetry/core/build/esm/index.js
+var internal = {
+  _export
+};
+
+// node_modules/@opentelemetry/sdk-trace-base/build/esm/export/BatchSpanProcessorBase.js
+var import_api5 = require("@opentelemetry/api");
+var BatchSpanProcessorBase = class {
+  _maxExportBatchSize;
+  _maxQueueSize;
+  _scheduledDelayMillis;
+  _exportTimeoutMillis;
+  _exporter;
+  _isExporting = false;
+  _finishedSpans = [];
+  _timer;
+  _shutdownOnce;
+  _droppedSpansCount = 0;
+  constructor(exporter, config) {
+    this._exporter = exporter;
+    this._maxExportBatchSize = typeof config?.maxExportBatchSize === "number" ? config.maxExportBatchSize : getNumberFromEnv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE") ?? 512;
+    this._maxQueueSize = typeof config?.maxQueueSize === "number" ? config.maxQueueSize : getNumberFromEnv("OTEL_BSP_MAX_QUEUE_SIZE") ?? 2048;
+    this._scheduledDelayMillis = typeof config?.scheduledDelayMillis === "number" ? config.scheduledDelayMillis : getNumberFromEnv("OTEL_BSP_SCHEDULE_DELAY") ?? 5e3;
+    this._exportTimeoutMillis = typeof config?.exportTimeoutMillis === "number" ? config.exportTimeoutMillis : getNumberFromEnv("OTEL_BSP_EXPORT_TIMEOUT") ?? 3e4;
+    this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+    if (this._maxExportBatchSize > this._maxQueueSize) {
+      import_api5.diag.warn("BatchSpanProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize");
+      this._maxExportBatchSize = this._maxQueueSize;
+    }
+  }
+  forceFlush() {
+    if (this._shutdownOnce.isCalled) {
+      return this._shutdownOnce.promise;
+    }
+    return this._flushAll();
+  }
+  // does nothing.
+  onStart(_span, _parentContext) {
+  }
+  onEnd(span) {
+    if (this._shutdownOnce.isCalled) {
+      return;
+    }
+    if ((span.spanContext().traceFlags & import_api5.TraceFlags.SAMPLED) === 0) {
+      return;
+    }
+    this._addToBuffer(span);
+  }
+  shutdown() {
+    return this._shutdownOnce.call();
+  }
+  _shutdown() {
+    return Promise.resolve().then(() => {
+      return this.onShutdown();
+    }).then(() => {
+      return this._flushAll();
+    }).then(() => {
+      return this._exporter.shutdown();
+    });
+  }
+  /** Add a span in the buffer. */
+  _addToBuffer(span) {
+    if (this._finishedSpans.length >= this._maxQueueSize) {
+      if (this._droppedSpansCount === 0) {
+        import_api5.diag.debug("maxQueueSize reached, dropping spans");
+      }
+      this._droppedSpansCount++;
+      return;
+    }
+    if (this._droppedSpansCount > 0) {
+      import_api5.diag.warn(`Dropped ${this._droppedSpansCount} spans because maxQueueSize reached`);
+      this._droppedSpansCount = 0;
+    }
+    this._finishedSpans.push(span);
+    this._maybeStartTimer();
+  }
+  /**
+   * Send all spans to the exporter respecting the batch size limit
+   * This function is used only on forceFlush or shutdown,
+   * for all other cases _flush should be used
+   * */
+  _flushAll() {
+    return new Promise((resolve, reject) => {
+      const promises = [];
+      const count = Math.ceil(this._finishedSpans.length / this._maxExportBatchSize);
+      for (let i = 0, j = count; i < j; i++) {
+        promises.push(this._flushOneBatch());
+      }
+      Promise.all(promises).then(() => {
+        resolve();
+      }).catch(reject);
+    });
+  }
+  _flushOneBatch() {
+    this._clearTimer();
+    if (this._finishedSpans.length === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error("Timeout"));
+      }, this._exportTimeoutMillis);
+      import_api5.context.with(suppressTracing(import_api5.context.active()), () => {
+        let spans;
+        if (this._finishedSpans.length <= this._maxExportBatchSize) {
+          spans = this._finishedSpans;
+          this._finishedSpans = [];
+        } else {
+          spans = this._finishedSpans.splice(0, this._maxExportBatchSize);
+        }
+        const doExport = () => this._exporter.export(spans, (result) => {
+          clearTimeout(timer);
+          if (result.code === ExportResultCode.SUCCESS) {
+            resolve();
+          } else {
+            reject(result.error ?? new Error("BatchSpanProcessor: span export failed"));
+          }
+        });
+        let pendingResources = null;
+        for (let i = 0, len = spans.length; i < len; i++) {
+          const span = spans[i];
+          if (span.resource.asyncAttributesPending && span.resource.waitForAsyncAttributes) {
+            pendingResources ??= [];
+            pendingResources.push(span.resource.waitForAsyncAttributes());
+          }
+        }
+        if (pendingResources === null) {
+          doExport();
+        } else {
+          Promise.all(pendingResources).then(doExport, (err) => {
+            globalErrorHandler(err);
+            reject(err);
+          });
+        }
+      });
+    });
+  }
+  _maybeStartTimer() {
+    if (this._isExporting)
+      return;
+    const flush = () => {
+      this._isExporting = true;
+      this._flushOneBatch().finally(() => {
+        this._isExporting = false;
+        if (this._finishedSpans.length > 0) {
+          this._clearTimer();
+          this._maybeStartTimer();
+        }
+      }).catch((e) => {
+        this._isExporting = false;
+        globalErrorHandler(e);
+      });
+    };
+    if (this._finishedSpans.length >= this._maxExportBatchSize) {
+      return flush();
+    }
+    if (this._timer !== void 0)
+      return;
+    this._timer = setTimeout(() => flush(), this._scheduledDelayMillis);
+    if (typeof this._timer !== "number") {
+      this._timer.unref();
+    }
+  }
+  _clearTimer() {
+    if (this._timer !== void 0) {
+      clearTimeout(this._timer);
+      this._timer = void 0;
+    }
+  }
+};
+
+// node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/export/BatchSpanProcessor.js
+var BatchSpanProcessor = class extends BatchSpanProcessorBase {
+  onShutdown() {
+  }
+};
+
+// node_modules/@opentelemetry/sdk-trace-base/build/esm/export/ConsoleSpanExporter.js
+var ConsoleSpanExporter = class {
+  /**
+   * Export spans.
+   * @param spans
+   * @param resultCallback
+   */
+  export(spans, resultCallback) {
+    return this._sendSpans(spans, resultCallback);
+  }
+  /**
+   * Shutdown the exporter.
+   */
+  shutdown() {
+    this._sendSpans([]);
+    return this.forceFlush();
+  }
+  /**
+   * Exports any pending spans in exporter
+   */
+  forceFlush() {
+    return Promise.resolve();
+  }
+  /**
+   * converts span info into more readable format
+   * @param span
+   */
+  _exportInfo(span) {
+    return {
+      resource: {
+        attributes: span.resource.attributes
+      },
+      instrumentationScope: span.instrumentationScope,
+      traceId: span.spanContext().traceId,
+      parentSpanContext: span.parentSpanContext,
+      traceState: span.spanContext().traceState?.serialize(),
+      name: span.name,
+      id: span.spanContext().spanId,
+      kind: span.kind,
+      timestamp: hrTimeToMicroseconds(span.startTime),
+      duration: hrTimeToMicroseconds(span.duration),
+      attributes: span.attributes,
+      status: span.status,
+      events: span.events,
+      links: span.links
+    };
+  }
+  /**
+   * Showing spans in console
+   * @param spans
+   * @param done
+   */
+  _sendSpans(spans, done) {
+    for (const span of spans) {
+      console.dir(this._exportInfo(span), { depth: 3 });
+    }
+    if (done) {
+      return done({ code: ExportResultCode.SUCCESS });
+    }
+  }
+};
+
+// node_modules/@opentelemetry/sdk-trace-base/build/esm/export/SimpleSpanProcessor.js
+var import_api6 = require("@opentelemetry/api");
+var SimpleSpanProcessor = class {
+  _exporter;
+  _shutdownOnce;
+  _pendingExports;
+  constructor(exporter) {
+    this._exporter = exporter;
+    this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+    this._pendingExports = /* @__PURE__ */ new Set();
+  }
+  async forceFlush() {
+    await Promise.all(Array.from(this._pendingExports));
+    if (this._exporter.forceFlush) {
+      await this._exporter.forceFlush();
+    }
+  }
+  onStart(_span, _parentContext) {
+  }
+  onEnd(span) {
+    if (this._shutdownOnce.isCalled) {
+      return;
+    }
+    if ((span.spanContext().traceFlags & import_api6.TraceFlags.SAMPLED) === 0) {
+      return;
+    }
+    const pendingExport = this._doExport(span).catch((err) => globalErrorHandler(err));
+    this._pendingExports.add(pendingExport);
+    void pendingExport.finally(() => this._pendingExports.delete(pendingExport));
+  }
+  async _doExport(span) {
+    if (span.resource.asyncAttributesPending) {
+      await span.resource.waitForAsyncAttributes?.();
+    }
+    const result = await internal._export(this._exporter, [span]);
+    if (result.code !== ExportResultCode.SUCCESS) {
+      throw result.error ?? new Error(`SimpleSpanProcessor: span export failed (status ${result})`);
+    }
+  }
+  shutdown() {
+    return this._shutdownOnce.call();
+  }
+  _shutdown() {
+    return this._exporter.shutdown();
+  }
+};
+
+// 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_resources = require("@opentelemetry/resources");
+var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+
+// node_modules/@opentelemetry/instrumentation/build/esm/autoLoader.js
+var import_api7 = require("@opentelemetry/api");
+
+// node_modules/@opentelemetry/api-logs/build/esm/NoopLogger.js
+var NoopLogger = class {
+  emit(_logRecord) {
+  }
+};
+var NOOP_LOGGER = new NoopLogger();
+
+// node_modules/@opentelemetry/api-logs/build/esm/NoopLoggerProvider.js
+var NoopLoggerProvider = class {
+  getLogger(_name, _version, _options) {
+    return new NoopLogger();
+  }
+};
+var NOOP_LOGGER_PROVIDER = new NoopLoggerProvider();
+
+// node_modules/@opentelemetry/api-logs/build/esm/ProxyLogger.js
+var ProxyLogger = class {
+  constructor(provider, name, version, options) {
+    this._provider = provider;
+    this.name = name;
+    this.version = version;
+    this.options = options;
+  }
+  /**
+   * Emit a log record. This method should only be used by log appenders.
+   *
+   * @param logRecord
+   */
+  emit(logRecord) {
+    this._getLogger().emit(logRecord);
+  }
+  /**
+   * Try to get a logger from the proxy logger provider.
+   * If the proxy logger provider has no delegate, return a noop logger.
+   */
+  _getLogger() {
+    if (this._delegate) {
+      return this._delegate;
+    }
+    const logger = this._provider._getDelegateLogger(this.name, this.version, this.options);
+    if (!logger) {
+      return NOOP_LOGGER;
+    }
+    this._delegate = logger;
+    return this._delegate;
+  }
+};
+
+// node_modules/@opentelemetry/api-logs/build/esm/ProxyLoggerProvider.js
+var ProxyLoggerProvider = class {
+  getLogger(name, version, options) {
+    var _a;
+    return (_a = this._getDelegateLogger(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyLogger(this, name, version, options);
+  }
+  /**
+   * Get the delegate logger provider.
+   * Used by tests only.
+   * @internal
+   */
+  _getDelegate() {
+    var _a;
+    return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_LOGGER_PROVIDER;
+  }
+  /**
+   * Set the delegate logger provider
+   * @internal
+   */
+  _setDelegate(delegate) {
+    this._delegate = delegate;
+  }
+  /**
+   * @internal
+   */
+  _getDelegateLogger(name, version, options) {
+    var _a;
+    return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getLogger(name, version, options);
+  }
+};
+
+// node_modules/@opentelemetry/api-logs/build/esm/internal/global-utils.js
+var GLOBAL_LOGS_API_KEY = /* @__PURE__ */ Symbol.for("io.opentelemetry.js.api.logs");
+var _global = globalThis;
+function makeGetter(requiredVersion, instance, fallback) {
+  return (version) => version === requiredVersion ? instance : fallback;
+}
+var API_BACKWARDS_COMPATIBILITY_VERSION = 1;
+
+// node_modules/@opentelemetry/api-logs/build/esm/api/logs.js
+var LogsAPI = class _LogsAPI {
+  constructor() {
+    this._proxyLoggerProvider = new ProxyLoggerProvider();
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _LogsAPI();
+    }
+    return this._instance;
+  }
+  setGlobalLoggerProvider(provider) {
+    if (_global[GLOBAL_LOGS_API_KEY]) {
+      return this.getLoggerProvider();
+    }
+    _global[GLOBAL_LOGS_API_KEY] = makeGetter(API_BACKWARDS_COMPATIBILITY_VERSION, provider, NOOP_LOGGER_PROVIDER);
+    this._proxyLoggerProvider._setDelegate(provider);
+    return provider;
+  }
+  /**
+   * Returns the global logger provider.
+   *
+   * @returns LoggerProvider
+   */
+  getLoggerProvider() {
+    var _a, _b;
+    return (_b = (_a = _global[GLOBAL_LOGS_API_KEY]) === null || _a === void 0 ? void 0 : _a.call(_global, API_BACKWARDS_COMPATIBILITY_VERSION)) !== null && _b !== void 0 ? _b : this._proxyLoggerProvider;
+  }
+  /**
+   * Returns a logger from the global logger provider.
+   *
+   * @returns Logger
+   */
+  getLogger(name, version, options) {
+    return this.getLoggerProvider().getLogger(name, version, options);
+  }
+  /** Remove the global logger provider */
+  disable() {
+    delete _global[GLOBAL_LOGS_API_KEY];
+    this._proxyLoggerProvider = new ProxyLoggerProvider();
+  }
+};
+
+// node_modules/@opentelemetry/api-logs/build/esm/index.js
+var logs = LogsAPI.getInstance();
+
+// node_modules/@opentelemetry/instrumentation/build/esm/autoLoaderUtils.js
+function enableInstrumentations(instrumentations, tracerProvider, meterProvider, loggerProvider) {
+  for (let i = 0, j = instrumentations.length; i < j; i++) {
+    const instrumentation = instrumentations[i];
+    if (tracerProvider) {
+      instrumentation.setTracerProvider(tracerProvider);
+    }
+    if (meterProvider) {
+      instrumentation.setMeterProvider(meterProvider);
+    }
+    if (loggerProvider && instrumentation.setLoggerProvider) {
+      instrumentation.setLoggerProvider(loggerProvider);
+    }
+    if (!instrumentation.getConfig().enabled) {
+      instrumentation.enable();
+    }
+  }
+}
+function disableInstrumentations(instrumentations) {
+  instrumentations.forEach((instrumentation) => instrumentation.disable());
+}
+
+// node_modules/@opentelemetry/instrumentation/build/esm/autoLoader.js
+function registerInstrumentations(options) {
+  const tracerProvider = options.tracerProvider || import_api7.trace.getTracerProvider();
+  const meterProvider = options.meterProvider || import_api7.metrics.getMeterProvider();
+  const loggerProvider = options.loggerProvider || logs.getLoggerProvider();
+  const instrumentations = options.instrumentations?.flat() ?? [];
+  enableInstrumentations(instrumentations, tracerProvider, meterProvider, loggerProvider);
+  return () => {
+    disableInstrumentations(instrumentations);
+  };
+}
+
+// src/sdk.ts
+var import_auto_instrumentations_node = require("@opentelemetry/auto-instrumentations-node");
+
 // src/config.ts
 var DEFAULT_CONFIG = {
   environment: "development",
@@ -127,357 +749,143 @@ function parseBoolEnv(name, defaultValue) {
   return value.toLowerCase() === "true" || value === "1";
 }
 
-// src/transport.ts
-var defaultLogger = {
-  debug: (msg, ...args) => console.debug(`[tracebeam] ${msg}`, ...args),
-  warn: (msg, ...args) => console.warn(`[tracebeam] ${msg}`, ...args),
-  error: (msg, ...args) => console.error(`[tracebeam] ${msg}`, ...args)
-};
-var Transport = class {
-  endpoint;
-  apiKey;
-  timeout;
-  logger;
-  debug;
-  state = "active";
-  constructor(options) {
-    this.endpoint = options.endpoint.replace(/\/$/, "");
-    this.apiKey = options.apiKey;
-    this.timeout = options.timeout;
-    this.debug = options.debug;
-    this.logger = options.logger ?? defaultLogger;
-  }
-  /**
-   * Get current transport state
-   */
-  getState() {
-    return this.state;
-  }
-  /**
-   * Check if transport is active
-   */
-  isActive() {
-    return this.state === "active";
-  }
-  /**
-   * Send a batch of events to the Ingest API
-   * Implements retry with exponential backoff
-   */
-  async send(events) {
-    if (!this.isActive()) {
-      return {
-        success: false,
-        error: "Transport disabled",
-        message: `Transport is ${this.state}`,
-        code: 0
-      };
-    }
-    const batch = { events };
-    const url = `${this.endpoint}/api/v1/events`;
-    let lastError = null;
-    const maxRetries = 3;
-    const baseDelay = 1e3;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        const response = await this.executeRequest(url, batch);
-        if (response.success) {
-          if (this.debug) {
-            this.logger.debug(`Sent ${events.length} events successfully`);
-          }
-          return response;
-        }
-        const errorResponse = response;
-        lastError = errorResponse;
-        switch (errorResponse.code) {
-          case 401:
-            this.state = "disabled";
-            this.logger.error("Invalid API key. SDK disabled.");
-            return errorResponse;
-          case 402:
-            this.state = "quota_exceeded";
-            this.logger.warn("Event quota exceeded. SDK paused.");
-            return errorResponse;
-          case 429:
-            const retryAfter = errorResponse.retry_after ?? 1;
-            if (attempt < maxRetries) {
-              await this.sleep(retryAfter * 1e3);
-              continue;
-            }
-            return errorResponse;
-          case 400:
-            this.logger.warn("Bad request:", errorResponse.message);
-            return errorResponse;
-          default:
-            if (errorResponse.code >= 500 && attempt < maxRetries) {
-              const delay = this.calculateBackoff(attempt, baseDelay);
-              if (this.debug) {
-                this.logger.debug(`Retry ${attempt + 1}/${maxRetries} after ${delay}ms`);
-              }
-              await this.sleep(delay);
-              continue;
-            }
-            return errorResponse;
-        }
-      } catch (error) {
-        if (attempt < maxRetries) {
-          const delay = this.calculateBackoff(attempt, baseDelay);
-          if (this.debug) {
-            this.logger.debug(`Network error, retry ${attempt + 1}/${maxRetries} after ${delay}ms`);
-          }
-          await this.sleep(delay);
-          continue;
-        }
-        const networkError = {
-          success: false,
-          error: "Network Error",
-          message: error instanceof Error ? error.message : "Unknown error",
-          code: 0
-        };
-        return networkError;
-      }
-    }
-    return lastError ?? {
-      success: false,
-      error: "Max retries exceeded",
-      message: "Failed after maximum retry attempts",
-      code: 0
-    };
-  }
-  /**
-   * Execute HTTP request
-   */
-  async executeRequest(url, batch) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${this.apiKey}`
-        },
-        body: JSON.stringify(batch),
-        signal: controller.signal
-      });
-      const data = await response.json();
-      return data;
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  /**
-   * Calculate backoff delay with jitter
-   */
-  calculateBackoff(attempt, baseDelay) {
-    const exponentialDelay = baseDelay * Math.pow(2, attempt);
-    const jitter = exponentialDelay * 0.1 * (Math.random() * 2 - 1);
-    return Math.round(exponentialDelay + jitter);
-  }
-  /**
-   * Sleep for specified milliseconds
-   */
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-};
-
-// src/queue.ts
-var EventQueue = class {
-  queue = [];
-  options;
-  onFlush;
-  flushTimer = null;
-  isFlushing = false;
-  constructor(options, onFlush) {
-    this.options = options;
-    this.onFlush = onFlush;
-  }
-  /**
-   * Start the background flush timer
-   */
-  start() {
-    if (this.flushTimer) return;
-    this.flushTimer = setInterval(() => {
-      this.flush().catch(() => {
-      });
-    }, this.options.flushInterval);
-    if (this.flushTimer.unref) {
-      this.flushTimer.unref();
-    }
-  }
-  /**
-   * Stop the background flush timer
-   */
-  stop() {
-    if (this.flushTimer) {
-      clearInterval(this.flushTimer);
-      this.flushTimer = null;
-    }
-  }
-  /**
-   * Add an event to the queue
-   * Returns immediately (non-blocking)
-   */
-  add(event) {
-    if (this.queue.length >= this.options.maxQueueSize) {
-      this.queue.shift();
-      if (this.options.debug) {
-        console.warn("[tracebeam] Queue full, dropping oldest event");
-      }
-    }
-    this.queue.push(event);
-    if (this.queue.length >= this.options.batchSize) {
-      this.flush().catch(() => {
-      });
-    }
-  }
-  /**
-   * Flush all queued events
-   */
-  async flush() {
-    if (this.isFlushing || this.queue.length === 0) {
-      return;
-    }
-    this.isFlushing = true;
-    try {
-      const events = this.queue.splice(0, this.queue.length);
-      await this.onFlush(events);
-    } finally {
-      this.isFlushing = false;
-    }
-  }
-  /**
-   * Get current queue size
-   */
-  size() {
-    return this.queue.length;
-  }
-  /**
-   * Check if queue is empty
-   */
-  isEmpty() {
-    return this.queue.length === 0;
-  }
-};
-function createEvent(projectId, environment, error, options = {}, globalTags = {}, globalExtra = {}) {
-  if (!projectId || projectId.trim() === "") {
-    throw new ConfigError('createEvent: "projectId" must be a non-empty string.');
-  }
-  if (!environment || environment.trim() === "") {
-    throw new ConfigError('createEvent: "environment" must be a non-empty string.');
-  }
-  const level = options.level ?? "error";
-  const timestamp = options.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
-  const tags = {
-    ...globalTags,
-    ...options.tags
-  };
-  const extra = {
-    ...globalExtra,
-    ...options.extra
-  };
-  const truncatedError = error.length > 1e4 ? error.slice(0, 1e4) : error;
-  return {
-    project_id: projectId,
-    error: truncatedError,
-    level,
-    environment,
-    timestamp,
-    tags,
-    extra
-  };
-}
-
-// src/client.ts
+// src/sdk.ts
 var TraceBeamSDK = class _TraceBeamSDK {
   config;
-  transport;
-  queue;
+  provider;
+  tracer;
+  isInitialized = true;
   globalTags = {};
   globalExtra = {};
   userId = null;
-  isInitialized = true;
   /**
    * Create SDK instance from configuration
    */
   constructor(config) {
     validateConfig(config);
     this.config = mergeConfig(config);
-    this.transport = new Transport({
-      endpoint: this.config.endpoint,
-      apiKey: this.config.apiKey,
-      timeout: this.config.timeout,
-      debug: this.config.debug
+    const baseUrl = this.config.endpoint.replace(/\/$/, "");
+    const exporterUrl = `${baseUrl}/v1/traces`;
+    const exporter = new import_exporter_trace_otlp_http.OTLPTraceExporter({
+      url: exporterUrl,
+      headers: {
+        "Authorization": `Bearer ${this.config.apiKey}`
+      }
     });
-    this.queue = new EventQueue(
-      {
-        batchSize: this.config.batchSize,
-        flushInterval: this.config.flushInterval,
-        maxQueueSize: this.config.maxQueueSize,
-        debug: this.config.debug
-      },
-      this.handleFlush.bind(this)
-    );
-    this.queue.start();
+    const spanProcessors = [];
+    spanProcessors.push(new BatchSpanProcessor(exporter, {
+      maxExportBatchSize: this.config.batchSize,
+      scheduledDelayMillis: this.config.flushInterval
+    }));
     if (this.config.debug) {
-      console.debug("[tracebeam] Initialized", {
-        projectId: this.config.projectId,
-        environment: this.config.environment,
-        endpoint: this.config.endpoint
+      spanProcessors.push(new SimpleSpanProcessor(new ConsoleSpanExporter()));
+      console.debug("[tracebeam] Initialized OTLP", {
+        url: exporterUrl,
+        projectId: this.config.projectId
       });
     }
+    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"
+      }),
+      spanProcessors
+    });
+    this.provider.register();
+    registerInstrumentations({
+      tracerProvider: this.provider,
+      instrumentations: [
+        (0, import_auto_instrumentations_node.getNodeAutoInstrumentations)({
+          // Disable some noisy instrumentations
+          "@opentelemetry/instrumentation-fs": { enabled: false },
+          "@opentelemetry/instrumentation-dns": { enabled: false }
+        })
+      ]
+    });
+    this.tracer = api.trace.getTracer("tracebeam-sdk");
   }
-  /**
-   * Create SDK instance from environment variables
-   * 
-   * Required env vars:
-   * - TRACEBEAM_API_KEY
-   * - TRACEBEAM_PROJECT_ID
-   * 
-   * Optional env vars:
-   * - TRACEBEAM_ENVIRONMENT (default: 'development')
-   * - TRACEBEAM_ENDPOINT (default: 'https://ingest.tracebeam.io')
-   * - TRACEBEAM_BATCH_SIZE (default: 100)
-   * - TRACEBEAM_FLUSH_INTERVAL (default: 5000)
-   * - TRACEBEAM_HTTP_TIMEOUT (default: 10000)
-   * - TRACEBEAM_MAX_QUEUE_SIZE (default: 10000)
-   * - TRACEBEAM_SAMPLE_RATE (default: 1.0)
-   * - TRACEBEAM_DEBUG (default: false)
-   */
   static fromEnv() {
     const config = loadConfigFromEnv();
     return new _TraceBeamSDK(config);
   }
   /**
    * Capture an exception/error
-   * Returns immediately (non-blocking)
    */
   captureException(error, options = {}) {
     if (!this.canCapture()) return;
-    const errorMessage = error instanceof Error ? `${error.name}: ${error.message}
-${error.stack ?? ""}` : String(error);
-    const event = this.createEventWithContext(errorMessage, {
-      level: "error",
-      ...options
+    const timestamp = options.timestamp ? new Date(options.timestamp).getTime() : Date.now();
+    let startTime = timestamp;
+    if (options.latency) {
+      startTime = timestamp - options.latency;
+    }
+    let spanName = "exception";
+    let spanStatus = api.SpanStatusCode.ERROR;
+    let errorMessage = "";
+    if (error instanceof Error) {
+      spanName = error.name || "Error";
+      errorMessage = error.message;
+    } else if (typeof error === "string") {
+      if (error === "") {
+        spanName = options.tags?.["endpoint"] || "request";
+        spanStatus = api.SpanStatusCode.OK;
+      } else {
+        spanName = "Error";
+        errorMessage = error;
+      }
+    } else {
+      spanName = "Error";
+      errorMessage = String(error);
+    }
+    const span = this.tracer.startSpan(spanName, {
+      startTime,
+      kind: api.SpanKind.CLIENT
     });
-    this.queue.add(event);
+    const attributes = {};
+    Object.entries(this.globalTags).forEach(([k, v]) => attributes[k] = v);
+    if (options.tags) {
+      Object.entries(options.tags).forEach(([k, v]) => attributes[k] = v);
+    }
+    Object.entries(this.globalExtra).forEach(([k, v]) => {
+      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+        attributes[k] = v;
+      } else {
+        attributes[k] = JSON.stringify(v);
+      }
+    });
+    if (options.extra) {
+      Object.entries(options.extra).forEach(([k, v]) => {
+        if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+          attributes[k] = v;
+        } else {
+          attributes[k] = JSON.stringify(v);
+        }
+      });
+    }
+    if (options.latency) {
+      attributes["latency_ms"] = options.latency;
+      attributes["latency"] = options.latency;
+    }
+    span.setAttributes(attributes);
+    span.setStatus({ code: spanStatus });
+    if (error && error !== "") {
+      if (error instanceof Error) {
+        span.recordException(error);
+      } else {
+        span.recordException(new Error(String(error)));
+      }
+    }
+    span.end(timestamp);
   }
   /**
-   * Capture a message/event
-   * Returns immediately (non-blocking)
+   * Capture a message
    */
   captureMessage(message, options = {}) {
-    if (!this.canCapture()) return;
-    const event = this.createEventWithContext(message, {
-      level: "info",
-      ...options
-    });
-    this.queue.add(event);
+    this.captureException(message, { ...options, level: options.level || "info" });
   }
-  /**
-   * Set the current user ID
-   * Will be included in all subsequent events
-   */
   setUser(userId) {
     this.userId = userId;
     if (userId) {
@@ -486,62 +894,30 @@ ${error.stack ?? ""}` : String(error);
       delete this.globalExtra["user_id"];
     }
   }
-  /**
-   * Set a global tag
-   * Will be included in all subsequent events
-   */
   setTag(key, value) {
     this.globalTags[key] = value;
   }
-  /**
-   * Set multiple global tags
-   * Will be included in all subsequent events
-   */
   setTags(tags) {
     Object.assign(this.globalTags, tags);
   }
-  /**
-   * Set global extra context
-   * Will be included in all subsequent events
-   */
   setExtra(key, value) {
     this.globalExtra[key] = value;
   }
-  /**
-   * Set multiple global extra context values
-   */
   setExtras(extras) {
     Object.assign(this.globalExtra, extras);
   }
-  /**
-   * Manually flush queued events
-   * Call this to ensure events are sent before process exit
-   */
   async flush() {
-    await this.queue.flush();
+    await this.provider.forceFlush();
   }
-  /**
-   * Graceful shutdown
-   * Flushes remaining events and stops background workers
-   */
   async close() {
     this.isInitialized = false;
-    this.queue.stop();
-    await this.flush();
-    if (this.config.debug) {
-      console.debug("[tracebeam] Closed");
-    }
+    await this.provider.shutdown();
   }
-  /**
-   * Check if SDK is active and can capture events
-   */
   isActive() {
-    return this.isInitialized && this.transport.isActive();
+    return this.isInitialized;
   }
-  // Private methods
   canCapture() {
     if (!this.isInitialized) return false;
-    if (!this.transport.isActive()) return false;
     if (this.config.sampleRate < 1) {
       if (Math.random() > this.config.sampleRate) {
         return false;
@@ -549,32 +925,14 @@ ${error.stack ?? ""}` : String(error);
     }
     return true;
   }
-  createEventWithContext(error, options) {
-    return createEvent(
-      this.config.projectId,
-      this.config.environment,
-      error,
-      options,
-      this.globalTags,
-      this.globalExtra
-    );
-  }
-  async handleFlush(events) {
-    if (events.length === 0) return;
-    try {
-      await this.transport.send(events);
-    } catch (error) {
-      if (this.config.debug) {
-        console.error("[tracebeam] Failed to flush events:", error);
-      }
-    }
-  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ConfigError,
   DEFAULT_CONFIG,
   TraceBeamSDK,
-  loadConfigFromEnv
+  loadConfigFromEnv,
+  mergeConfig,
+  validateConfig
 });
 //# sourceMappingURL=index.js.map