@glasstrace/sdk 0.2.1 → 0.4.0

package/dist/adapters/drizzle.cjs

@@ -23,7 +23,733 @@ __export(drizzle_exports, {
   GlasstraceDrizzleLogger: () => GlasstraceDrizzleLogger
 });
 module.exports = __toCommonJS(drizzle_exports);
-var import_api = require("@opentelemetry/api");
+
+// ../../node_modules/@opentelemetry/api/build/esm/version.js
+var VERSION = "1.9.1";
+
+// ../../node_modules/@opentelemetry/api/build/esm/internal/semver.js
+var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+function _makeCompatibilityCheck(ownVersion) {
+  const acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+  const rejectedVersions = /* @__PURE__ */ new Set();
+  const myVersionMatch = ownVersion.match(re);
+  if (!myVersionMatch) {
+    return () => false;
+  }
+  const ownVersionParsed = {
+    major: +myVersionMatch[1],
+    minor: +myVersionMatch[2],
+    patch: +myVersionMatch[3],
+    prerelease: myVersionMatch[4]
+  };
+  if (ownVersionParsed.prerelease != null) {
+    return function isExactmatch(globalVersion) {
+      return globalVersion === ownVersion;
+    };
+  }
+  function _reject(v) {
+    rejectedVersions.add(v);
+    return false;
+  }
+  function _accept(v) {
+    acceptedVersions.add(v);
+    return true;
+  }
+  return function isCompatible2(globalVersion) {
+    if (acceptedVersions.has(globalVersion)) {
+      return true;
+    }
+    if (rejectedVersions.has(globalVersion)) {
+      return false;
+    }
+    const globalVersionMatch = globalVersion.match(re);
+    if (!globalVersionMatch) {
+      return _reject(globalVersion);
+    }
+    const globalVersionParsed = {
+      major: +globalVersionMatch[1],
+      minor: +globalVersionMatch[2],
+      patch: +globalVersionMatch[3],
+      prerelease: globalVersionMatch[4]
+    };
+    if (globalVersionParsed.prerelease != null) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major !== globalVersionParsed.major) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major === 0) {
+      if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+        return _accept(globalVersion);
+      }
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+      return _accept(globalVersion);
+    }
+    return _reject(globalVersion);
+  };
+}
+var isCompatible = _makeCompatibilityCheck(VERSION);
+
+// ../../node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
+var major = VERSION.split(".")[0];
+var GLOBAL_OPENTELEMETRY_API_KEY = /* @__PURE__ */ Symbol.for(`opentelemetry.js.api.${major}`);
+var _global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+function registerGlobal(type, instance, diag, allowOverride = false) {
+  var _a;
+  const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+    version: VERSION
+  };
+  if (!allowOverride && api[type]) {
+    const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
+    diag.error(err.stack || err.message);
+    return false;
+  }
+  if (api.version !== VERSION) {
+    const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${VERSION}`);
+    diag.error(err.stack || err.message);
+    return false;
+  }
+  api[type] = instance;
+  diag.debug(`@opentelemetry/api: Registered a global for ${type} v${VERSION}.`);
+  return true;
+}
+function getGlobal(type) {
+  var _a, _b;
+  const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+  if (!globalVersion || !isCompatible(globalVersion)) {
+    return;
+  }
+  return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+function unregisterGlobal(type, diag) {
+  diag.debug(`@opentelemetry/api: Unregistering a global for ${type} v${VERSION}.`);
+  const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+  if (api) {
+    delete api[type];
+  }
+}
+
+// ../../node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+var DiagComponentLogger = class {
+  constructor(props) {
+    this._namespace = props.namespace || "DiagComponentLogger";
+  }
+  debug(...args) {
+    return logProxy("debug", this._namespace, args);
+  }
+  error(...args) {
+    return logProxy("error", this._namespace, args);
+  }
+  info(...args) {
+    return logProxy("info", this._namespace, args);
+  }
+  warn(...args) {
+    return logProxy("warn", this._namespace, args);
+  }
+  verbose(...args) {
+    return logProxy("verbose", this._namespace, args);
+  }
+};
+function logProxy(funcName, namespace, args) {
+  const logger = getGlobal("diag");
+  if (!logger) {
+    return;
+  }
+  return logger[funcName](namespace, ...args);
+}
+
+// ../../node_modules/@opentelemetry/api/build/esm/diag/types.js
+var DiagLogLevel;
+(function(DiagLogLevel2) {
+  DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+  DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+  DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+  DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+  DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+  DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+  DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+})(DiagLogLevel || (DiagLogLevel = {}));
+
+// ../../node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
+function createLogLevelDiagLogger(maxLevel, logger) {
+  if (maxLevel < DiagLogLevel.NONE) {
+    maxLevel = DiagLogLevel.NONE;
+  } else if (maxLevel > DiagLogLevel.ALL) {
+    maxLevel = DiagLogLevel.ALL;
+  }
+  logger = logger || {};
+  function _filterFunc(funcName, theLevel) {
+    const theFunc = logger[funcName];
+    if (typeof theFunc === "function" && maxLevel >= theLevel) {
+      return theFunc.bind(logger);
+    }
+    return function() {
+    };
+  }
+  return {
+    error: _filterFunc("error", DiagLogLevel.ERROR),
+    warn: _filterFunc("warn", DiagLogLevel.WARN),
+    info: _filterFunc("info", DiagLogLevel.INFO),
+    debug: _filterFunc("debug", DiagLogLevel.DEBUG),
+    verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
+  };
+}
+
+// ../../node_modules/@opentelemetry/api/build/esm/api/diag.js
+var API_NAME = "diag";
+var DiagAPI = class _DiagAPI {
+  /** Get the singleton instance of the DiagAPI API */
+  static instance() {
+    if (!this._instance) {
+      this._instance = new _DiagAPI();
+    }
+    return this._instance;
+  }
+  /**
+   * Private internal constructor
+   * @private
+   */
+  constructor() {
+    function _logProxy(funcName) {
+      return function(...args) {
+        const logger = getGlobal("diag");
+        if (!logger)
+          return;
+        return logger[funcName](...args);
+      };
+    }
+    const self2 = this;
+    const setLogger = (logger, optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }) => {
+      var _a, _b, _c;
+      if (logger === self2) {
+        const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+        self2.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+        return false;
+      }
+      if (typeof optionsOrLogLevel === "number") {
+        optionsOrLogLevel = {
+          logLevel: optionsOrLogLevel
+        };
+      }
+      const oldLogger = getGlobal("diag");
+      const newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+      if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+        const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+        oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+        newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+      }
+      return registerGlobal("diag", newLogger, self2, true);
+    };
+    self2.setLogger = setLogger;
+    self2.disable = () => {
+      unregisterGlobal(API_NAME, self2);
+    };
+    self2.createComponentLogger = (options) => {
+      return new DiagComponentLogger(options);
+    };
+    self2.verbose = _logProxy("verbose");
+    self2.debug = _logProxy("debug");
+    self2.info = _logProxy("info");
+    self2.warn = _logProxy("warn");
+    self2.error = _logProxy("error");
+  }
+};
+
+// ../../node_modules/@opentelemetry/api/build/esm/context/context.js
+function createContextKey(description) {
+  return Symbol.for(description);
+}
+var BaseContext = class _BaseContext {
+  /**
+   * Construct a new context which inherits values from an optional parent context.
+   *
+   * @param parentContext a context from which to inherit values
+   */
+  constructor(parentContext) {
+    const self2 = this;
+    self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+    self2.getValue = (key) => self2._currentContext.get(key);
+    self2.setValue = (key, value) => {
+      const context = new _BaseContext(self2._currentContext);
+      context._currentContext.set(key, value);
+      return context;
+    };
+    self2.deleteValue = (key) => {
+      const context = new _BaseContext(self2._currentContext);
+      context._currentContext.delete(key);
+      return context;
+    };
+  }
+};
+var ROOT_CONTEXT = new BaseContext();
+
+// ../../node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
+var NoopContextManager = class {
+  active() {
+    return ROOT_CONTEXT;
+  }
+  with(_context, fn, thisArg, ...args) {
+    return fn.call(thisArg, ...args);
+  }
+  bind(_context, target) {
+    return target;
+  }
+  enable() {
+    return this;
+  }
+  disable() {
+    return this;
+  }
+};
+
+// ../../node_modules/@opentelemetry/api/build/esm/api/context.js
+var API_NAME2 = "context";
+var NOOP_CONTEXT_MANAGER = new NoopContextManager();
+var ContextAPI = class _ContextAPI {
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  constructor() {
+  }
+  /** Get the singleton instance of the Context API */
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _ContextAPI();
+    }
+    return this._instance;
+  }
+  /**
+   * Set the current context manager.
+   *
+   * @returns true if the context manager was successfully registered, else false
+   */
+  setGlobalContextManager(contextManager) {
+    return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
+  }
+  /**
+   * Get the currently active context
+   */
+  active() {
+    return this._getContextManager().active();
+  }
+  /**
+   * Execute a function with an active context
+   *
+   * @param context context to be active during function execution
+   * @param fn function to execute in a context
+   * @param thisArg optional receiver to be used for calling fn
+   * @param args optional arguments forwarded to fn
+   */
+  with(context, fn, thisArg, ...args) {
+    return this._getContextManager().with(context, fn, thisArg, ...args);
+  }
+  /**
+   * Bind a context to a target function or event emitter
+   *
+   * @param context context to bind to the event emitter or function. Defaults to the currently active context
+   * @param target function or event emitter to bind
+   */
+  bind(context, target) {
+    return this._getContextManager().bind(context, target);
+  }
+  _getContextManager() {
+    return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
+  }
+  /** Disable and remove the global context manager */
+  disable() {
+    this._getContextManager().disable();
+    unregisterGlobal(API_NAME2, DiagAPI.instance());
+  }
+};
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
+var TraceFlags;
+(function(TraceFlags2) {
+  TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
+  TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
+})(TraceFlags || (TraceFlags = {}));
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
+var INVALID_SPANID = "0000000000000000";
+var INVALID_TRACEID = "00000000000000000000000000000000";
+var INVALID_SPAN_CONTEXT = {
+  traceId: INVALID_TRACEID,
+  spanId: INVALID_SPANID,
+  traceFlags: TraceFlags.NONE
+};
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
+var NonRecordingSpan = class {
+  constructor(spanContext = INVALID_SPAN_CONTEXT) {
+    this._spanContext = spanContext;
+  }
+  // Returns a SpanContext.
+  spanContext() {
+    return this._spanContext;
+  }
+  // By default does nothing
+  setAttribute(_key, _value) {
+    return this;
+  }
+  // By default does nothing
+  setAttributes(_attributes) {
+    return this;
+  }
+  // By default does nothing
+  addEvent(_name, _attributes) {
+    return this;
+  }
+  addLink(_link) {
+    return this;
+  }
+  addLinks(_links) {
+    return this;
+  }
+  // By default does nothing
+  setStatus(_status) {
+    return this;
+  }
+  // By default does nothing
+  updateName(_name) {
+    return this;
+  }
+  // By default does nothing
+  end(_endTime) {
+  }
+  // isRecording always returns false for NonRecordingSpan.
+  isRecording() {
+    return false;
+  }
+  // By default does nothing
+  recordException(_exception, _time) {
+  }
+};
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
+var SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
+function getSpan(context) {
+  return context.getValue(SPAN_KEY) || void 0;
+}
+function getActiveSpan() {
+  return getSpan(ContextAPI.getInstance().active());
+}
+function setSpan(context, span) {
+  return context.setValue(SPAN_KEY, span);
+}
+function deleteSpan(context) {
+  return context.deleteValue(SPAN_KEY);
+}
+function setSpanContext(context, spanContext) {
+  return setSpan(context, new NonRecordingSpan(spanContext));
+}
+function getSpanContext(context) {
+  var _a;
+  return (_a = getSpan(context)) === null || _a === void 0 ? void 0 : _a.spanContext();
+}
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
+var isHex = new Uint8Array([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1
+]);
+function isValidHex(id, length) {
+  if (typeof id !== "string" || id.length !== length)
+    return false;
+  let r = 0;
+  for (let i = 0; i < id.length; i += 4) {
+    r += (isHex[id.charCodeAt(i)] | 0) + (isHex[id.charCodeAt(i + 1)] | 0) + (isHex[id.charCodeAt(i + 2)] | 0) + (isHex[id.charCodeAt(i + 3)] | 0);
+  }
+  return r === length;
+}
+function isValidTraceId(traceId) {
+  return isValidHex(traceId, 32) && traceId !== INVALID_TRACEID;
+}
+function isValidSpanId(spanId) {
+  return isValidHex(spanId, 16) && spanId !== INVALID_SPANID;
+}
+function isSpanContextValid(spanContext) {
+  return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+}
+function wrapSpanContext(spanContext) {
+  return new NonRecordingSpan(spanContext);
+}
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
+var contextApi = ContextAPI.getInstance();
+var NoopTracer = class {
+  // startSpan starts a noop span.
+  startSpan(name, options, context = contextApi.active()) {
+    const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
+    if (root) {
+      return new NonRecordingSpan();
+    }
+    const parentFromContext = context && getSpanContext(context);
+    if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
+      return new NonRecordingSpan(parentFromContext);
+    } else {
+      return new NonRecordingSpan();
+    }
+  }
+  startActiveSpan(name, arg2, arg3, arg4) {
+    let opts;
+    let ctx;
+    let fn;
+    if (arguments.length < 2) {
+      return;
+    } else if (arguments.length === 2) {
+      fn = arg2;
+    } else if (arguments.length === 3) {
+      opts = arg2;
+      fn = arg3;
+    } else {
+      opts = arg2;
+      ctx = arg3;
+      fn = arg4;
+    }
+    const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+    const span = this.startSpan(name, opts, parentContext);
+    const contextWithSpanSet = setSpan(parentContext, span);
+    return contextApi.with(contextWithSpanSet, fn, void 0, span);
+  }
+};
+function isSpanContext(spanContext) {
+  return spanContext !== null && typeof spanContext === "object" && "spanId" in spanContext && typeof spanContext["spanId"] === "string" && "traceId" in spanContext && typeof spanContext["traceId"] === "string" && "traceFlags" in spanContext && typeof spanContext["traceFlags"] === "number";
+}
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
+var NOOP_TRACER = new NoopTracer();
+var ProxyTracer = class {
+  constructor(provider, name, version, options) {
+    this._provider = provider;
+    this.name = name;
+    this.version = version;
+    this.options = options;
+  }
+  startSpan(name, options, context) {
+    return this._getTracer().startSpan(name, options, context);
+  }
+  startActiveSpan(_name, _options, _context, _fn) {
+    const tracer = this._getTracer();
+    return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
+  }
+  /**
+   * Try to get a tracer from the proxy tracer provider.
+   * If the proxy tracer provider has no delegate, return a noop tracer.
+   */
+  _getTracer() {
+    if (this._delegate) {
+      return this._delegate;
+    }
+    const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
+    if (!tracer) {
+      return NOOP_TRACER;
+    }
+    this._delegate = tracer;
+    return this._delegate;
+  }
+};
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
+var NoopTracerProvider = class {
+  getTracer(_name, _version, _options) {
+    return new NoopTracer();
+  }
+};
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
+var NOOP_TRACER_PROVIDER = new NoopTracerProvider();
+var ProxyTracerProvider = class {
+  /**
+   * Get a {@link ProxyTracer}
+   */
+  getTracer(name, version, options) {
+    var _a;
+    return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
+  }
+  getDelegate() {
+    var _a;
+    return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
+  }
+  /**
+   * Set the delegate tracer provider
+   */
+  setDelegate(delegate) {
+    this._delegate = delegate;
+  }
+  getDelegateTracer(name, version, options) {
+    var _a;
+    return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
+  }
+};
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/span_kind.js
+var SpanKind;
+(function(SpanKind2) {
+  SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL";
+  SpanKind2[SpanKind2["SERVER"] = 1] = "SERVER";
+  SpanKind2[SpanKind2["CLIENT"] = 2] = "CLIENT";
+  SpanKind2[SpanKind2["PRODUCER"] = 3] = "PRODUCER";
+  SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER";
+})(SpanKind || (SpanKind = {}));
+
+// ../../node_modules/@opentelemetry/api/build/esm/api/trace.js
+var API_NAME3 = "trace";
+var TraceAPI = class _TraceAPI {
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  constructor() {
+    this._proxyTracerProvider = new ProxyTracerProvider();
+    this.wrapSpanContext = wrapSpanContext;
+    this.isSpanContextValid = isSpanContextValid;
+    this.deleteSpan = deleteSpan;
+    this.getSpan = getSpan;
+    this.getActiveSpan = getActiveSpan;
+    this.getSpanContext = getSpanContext;
+    this.setSpan = setSpan;
+    this.setSpanContext = setSpanContext;
+  }
+  /** Get the singleton instance of the Trace API */
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _TraceAPI();
+    }
+    return this._instance;
+  }
+  /**
+   * Set the current global tracer.
+   *
+   * @returns true if the tracer provider was successfully registered, else false
+   */
+  setGlobalTracerProvider(provider) {
+    const success = registerGlobal(API_NAME3, this._proxyTracerProvider, DiagAPI.instance());
+    if (success) {
+      this._proxyTracerProvider.setDelegate(provider);
+    }
+    return success;
+  }
+  /**
+   * Returns the global tracer provider.
+   */
+  getTracerProvider() {
+    return getGlobal(API_NAME3) || this._proxyTracerProvider;
+  }
+  /**
+   * Returns a tracer from the global tracer provider.
+   */
+  getTracer(name, version) {
+    return this.getTracerProvider().getTracer(name, version);
+  }
+  /** Remove the global tracer provider */
+  disable() {
+    unregisterGlobal(API_NAME3, DiagAPI.instance());
+    this._proxyTracerProvider = new ProxyTracerProvider();
+  }
+};
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace-api.js
+var trace = TraceAPI.getInstance();
+
+// src/adapters/drizzle.ts
 function extractOperation(query) {
   const trimmed = query.trimStart().toUpperCase();
   if (trimmed.startsWith("SELECT")) return "SELECT";
@@ -45,7 +771,7 @@ var GlasstraceDrizzleLogger = class {
   tracer;
   captureParams;
   constructor(options) {
-    this.tracer = import_api.trace.getTracer("glasstrace-drizzle");
+    this.tracer = trace.getTracer("glasstrace-drizzle");
     this.captureParams = options?.captureParams ?? false;
   }
   /**
@@ -56,7 +782,7 @@ var GlasstraceDrizzleLogger = class {
     const operation = extractOperation(query);
     const spanName = operation === "unknown" ? "drizzle.query" : `drizzle.${operation}`;
     const span = this.tracer.startSpan(spanName, {
-      kind: import_api.SpanKind.CLIENT,
+      kind: SpanKind.CLIENT,
       attributes: {
         "db.system": "drizzle",
         "db.statement": query,