@obtrace/browser 2.2.0 → 2.4.0

package/dist/browser_entry.bundle.js

@@ -13504,6 +13504,168 @@ var TraceAPI = class _TraceAPI {
 // node_modules/@opentelemetry/api/build/esm/trace-api.js
 var trace = TraceAPI.getInstance();
 
+// node_modules/@opentelemetry/api-logs/build/esm/types/LogRecord.js
+var SeverityNumber;
+(function(SeverityNumber3) {
+  SeverityNumber3[SeverityNumber3["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  SeverityNumber3[SeverityNumber3["TRACE"] = 1] = "TRACE";
+  SeverityNumber3[SeverityNumber3["TRACE2"] = 2] = "TRACE2";
+  SeverityNumber3[SeverityNumber3["TRACE3"] = 3] = "TRACE3";
+  SeverityNumber3[SeverityNumber3["TRACE4"] = 4] = "TRACE4";
+  SeverityNumber3[SeverityNumber3["DEBUG"] = 5] = "DEBUG";
+  SeverityNumber3[SeverityNumber3["DEBUG2"] = 6] = "DEBUG2";
+  SeverityNumber3[SeverityNumber3["DEBUG3"] = 7] = "DEBUG3";
+  SeverityNumber3[SeverityNumber3["DEBUG4"] = 8] = "DEBUG4";
+  SeverityNumber3[SeverityNumber3["INFO"] = 9] = "INFO";
+  SeverityNumber3[SeverityNumber3["INFO2"] = 10] = "INFO2";
+  SeverityNumber3[SeverityNumber3["INFO3"] = 11] = "INFO3";
+  SeverityNumber3[SeverityNumber3["INFO4"] = 12] = "INFO4";
+  SeverityNumber3[SeverityNumber3["WARN"] = 13] = "WARN";
+  SeverityNumber3[SeverityNumber3["WARN2"] = 14] = "WARN2";
+  SeverityNumber3[SeverityNumber3["WARN3"] = 15] = "WARN3";
+  SeverityNumber3[SeverityNumber3["WARN4"] = 16] = "WARN4";
+  SeverityNumber3[SeverityNumber3["ERROR"] = 17] = "ERROR";
+  SeverityNumber3[SeverityNumber3["ERROR2"] = 18] = "ERROR2";
+  SeverityNumber3[SeverityNumber3["ERROR3"] = 19] = "ERROR3";
+  SeverityNumber3[SeverityNumber3["ERROR4"] = 20] = "ERROR4";
+  SeverityNumber3[SeverityNumber3["FATAL"] = 21] = "FATAL";
+  SeverityNumber3[SeverityNumber3["FATAL2"] = 22] = "FATAL2";
+  SeverityNumber3[SeverityNumber3["FATAL3"] = 23] = "FATAL3";
+  SeverityNumber3[SeverityNumber3["FATAL4"] = 24] = "FATAL4";
+})(SeverityNumber || (SeverityNumber = {}));
+
+// node_modules/@opentelemetry/api-logs/build/esm/NoopLogger.js
+var NoopLogger = (
+  /** @class */
+  (function() {
+    function NoopLogger5() {
+    }
+    NoopLogger5.prototype.emit = function(_logRecord) {
+    };
+    return NoopLogger5;
+  })()
+);
+var NOOP_LOGGER = new NoopLogger();
+
+// node_modules/@opentelemetry/api-logs/build/esm/NoopLoggerProvider.js
+var NoopLoggerProvider = (
+  /** @class */
+  (function() {
+    function NoopLoggerProvider5() {
+    }
+    NoopLoggerProvider5.prototype.getLogger = function(_name, _version, _options) {
+      return new NoopLogger();
+    };
+    return NoopLoggerProvider5;
+  })()
+);
+var NOOP_LOGGER_PROVIDER = new NoopLoggerProvider();
+
+// node_modules/@opentelemetry/api-logs/build/esm/ProxyLogger.js
+var ProxyLogger = (
+  /** @class */
+  (function() {
+    function ProxyLogger5(_provider, name, version, options) {
+      this._provider = _provider;
+      this.name = name;
+      this.version = version;
+      this.options = options;
+    }
+    ProxyLogger5.prototype.emit = function(logRecord) {
+      this._getLogger().emit(logRecord);
+    };
+    ProxyLogger5.prototype._getLogger = function() {
+      if (this._delegate) {
+        return this._delegate;
+      }
+      var logger = this._provider.getDelegateLogger(this.name, this.version, this.options);
+      if (!logger) {
+        return NOOP_LOGGER;
+      }
+      this._delegate = logger;
+      return this._delegate;
+    };
+    return ProxyLogger5;
+  })()
+);
+
+// node_modules/@opentelemetry/api-logs/build/esm/ProxyLoggerProvider.js
+var ProxyLoggerProvider = (
+  /** @class */
+  (function() {
+    function ProxyLoggerProvider5() {
+    }
+    ProxyLoggerProvider5.prototype.getLogger = function(name, version, options) {
+      var _a4;
+      return (_a4 = this.getDelegateLogger(name, version, options)) !== null && _a4 !== void 0 ? _a4 : new ProxyLogger(this, name, version, options);
+    };
+    ProxyLoggerProvider5.prototype.getDelegate = function() {
+      var _a4;
+      return (_a4 = this._delegate) !== null && _a4 !== void 0 ? _a4 : NOOP_LOGGER_PROVIDER;
+    };
+    ProxyLoggerProvider5.prototype.setDelegate = function(delegate) {
+      this._delegate = delegate;
+    };
+    ProxyLoggerProvider5.prototype.getDelegateLogger = function(name, version, options) {
+      var _a4;
+      return (_a4 = this._delegate) === null || _a4 === void 0 ? void 0 : _a4.getLogger(name, version, options);
+    };
+    return ProxyLoggerProvider5;
+  })()
+);
+
+// node_modules/@opentelemetry/api-logs/build/esm/platform/browser/globalThis.js
+var _globalThis = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+
+// 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 _global2 = _globalThis;
+function makeGetter(requiredVersion, instance, fallback) {
+  return function(version) {
+    return version === requiredVersion ? instance : fallback;
+  };
+}
+var API_BACKWARDS_COMPATIBILITY_VERSION = 1;
+
+// node_modules/@opentelemetry/api-logs/build/esm/api/logs.js
+var LogsAPI = (
+  /** @class */
+  (function() {
+    function LogsAPI5() {
+      this._proxyLoggerProvider = new ProxyLoggerProvider();
+    }
+    LogsAPI5.getInstance = function() {
+      if (!this._instance) {
+        this._instance = new LogsAPI5();
+      }
+      return this._instance;
+    };
+    LogsAPI5.prototype.setGlobalLoggerProvider = function(provider) {
+      if (_global2[GLOBAL_LOGS_API_KEY]) {
+        return this.getLoggerProvider();
+      }
+      _global2[GLOBAL_LOGS_API_KEY] = makeGetter(API_BACKWARDS_COMPATIBILITY_VERSION, provider, NOOP_LOGGER_PROVIDER);
+      this._proxyLoggerProvider.setDelegate(provider);
+      return provider;
+    };
+    LogsAPI5.prototype.getLoggerProvider = function() {
+      var _a4, _b;
+      return (_b = (_a4 = _global2[GLOBAL_LOGS_API_KEY]) === null || _a4 === void 0 ? void 0 : _a4.call(_global2, API_BACKWARDS_COMPATIBILITY_VERSION)) !== null && _b !== void 0 ? _b : this._proxyLoggerProvider;
+    };
+    LogsAPI5.prototype.getLogger = function(name, version, options) {
+      return this.getLoggerProvider().getLogger(name, version, options);
+    };
+    LogsAPI5.prototype.disable = function() {
+      delete _global2[GLOBAL_LOGS_API_KEY];
+      this._proxyLoggerProvider = new ProxyLoggerProvider();
+    };
+    return LogsAPI5;
+  })()
+);
+
+// node_modules/@opentelemetry/api-logs/build/esm/index.js
+var logs = LogsAPI.getInstance();
+
 // src/browser/offline.ts
 var DB_NAME = "obtrace_offline";
 var STORE_NAME = "queue";
@@ -14186,15 +14348,15 @@ function parseEnvironment(values) {
 }
 
 // node_modules/@opentelemetry/core/build/esm/platform/browser/globalThis.js
-var _globalThis = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+var _globalThis2 = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
 
 // node_modules/@opentelemetry/core/build/esm/platform/browser/environment.js
 function getEnv() {
-  var globalEnv = parseEnvironment(_globalThis);
+  var globalEnv = parseEnvironment(_globalThis2);
   return Object.assign({}, DEFAULT_ENVIRONMENT, globalEnv);
 }
 function getEnvWithoutDefaults() {
-  return parseEnvironment(_globalThis);
+  return parseEnvironment(_globalThis2);
 }
 
 // node_modules/@opentelemetry/core/build/esm/common/hex-to-binary.js
@@ -14315,9 +14477,9 @@ function addHrTimes(time1, time2) {
 
 // node_modules/@opentelemetry/core/build/esm/ExportResult.js
 var ExportResultCode;
-(function(ExportResultCode2) {
-  ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
-  ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
+(function(ExportResultCode4) {
+  ExportResultCode4[ExportResultCode4["SUCCESS"] = 0] = "SUCCESS";
+  ExportResultCode4[ExportResultCode4["FAILED"] = 1] = "FAILED";
 })(ExportResultCode || (ExportResultCode = {}));
 
 // node_modules/@opentelemetry/core/build/esm/propagation/composite.js
@@ -14747,27 +14909,27 @@ function isUrlIgnored(url, ignoredUrls) {
 var Deferred = (
   /** @class */
   (function() {
-    function Deferred2() {
+    function Deferred3() {
       var _this = this;
       this._promise = new Promise(function(resolve2, reject) {
         _this._resolve = resolve2;
         _this._reject = reject;
       });
     }
-    Object.defineProperty(Deferred2.prototype, "promise", {
+    Object.defineProperty(Deferred3.prototype, "promise", {
       get: function() {
         return this._promise;
       },
       enumerable: false,
       configurable: true
     });
-    Deferred2.prototype.resolve = function(val) {
+    Deferred3.prototype.resolve = function(val) {
       this._resolve(val);
     };
-    Deferred2.prototype.reject = function(err) {
+    Deferred3.prototype.reject = function(err) {
       this._reject(err);
     };
-    return Deferred2;
+    return Deferred3;
   })()
 );
 
@@ -14801,27 +14963,27 @@ var __spreadArray = function(to, from, pack) {
 var BindOnceFuture = (
   /** @class */
   (function() {
-    function BindOnceFuture2(_callback, _that) {
+    function BindOnceFuture3(_callback, _that) {
       this._callback = _callback;
       this._that = _that;
       this._isCalled = false;
       this._deferred = new Deferred();
     }
-    Object.defineProperty(BindOnceFuture2.prototype, "isCalled", {
+    Object.defineProperty(BindOnceFuture3.prototype, "isCalled", {
       get: function() {
         return this._isCalled;
       },
       enumerable: false,
       configurable: true
     });
-    Object.defineProperty(BindOnceFuture2.prototype, "promise", {
+    Object.defineProperty(BindOnceFuture3.prototype, "promise", {
       get: function() {
         return this._deferred.promise;
       },
       enumerable: false,
       configurable: true
     });
-    BindOnceFuture2.prototype.call = function() {
+    BindOnceFuture3.prototype.call = function() {
       var _a4;
       var _this = this;
       var args = [];
@@ -14842,7 +15004,7 @@ var BindOnceFuture = (
       }
       return this._deferred.promise;
     };
-    return BindOnceFuture2;
+    return BindOnceFuture3;
   })()
 );
 
@@ -16690,19 +16852,19 @@ function shouldPropagateTraceHeaders(spanUrl, propagateTraceHeaderCorsUrls) {
 var OTLPExporterBase = (
   /** @class */
   (function() {
-    function OTLPExporterBase2(_delegate) {
+    function OTLPExporterBase3(_delegate) {
       this._delegate = _delegate;
     }
-    OTLPExporterBase2.prototype.export = function(items, resultCallback) {
+    OTLPExporterBase3.prototype.export = function(items, resultCallback) {
       this._delegate.export(items, resultCallback);
     };
-    OTLPExporterBase2.prototype.forceFlush = function() {
+    OTLPExporterBase3.prototype.forceFlush = function() {
       return this._delegate.forceFlush();
     };
-    OTLPExporterBase2.prototype.shutdown = function() {
+    OTLPExporterBase3.prototype.shutdown = function() {
       return this._delegate.shutdown();
     };
-    return OTLPExporterBase2;
+    return OTLPExporterBase3;
   })()
 );
 
@@ -16729,15 +16891,15 @@ var __extends3 = /* @__PURE__ */ (function() {
 var OTLPExporterError = (
   /** @class */
   (function(_super) {
-    __extends3(OTLPExporterError2, _super);
-    function OTLPExporterError2(message, code, data) {
+    __extends3(OTLPExporterError3, _super);
+    function OTLPExporterError3(message, code, data) {
       var _this = _super.call(this, message) || this;
       _this.name = "OTLPExporterError";
       _this.data = data;
       _this.code = code;
       return _this;
     }
-    return OTLPExporterError2;
+    return OTLPExporterError3;
   })(Error)
 );
 
@@ -16872,11 +17034,11 @@ var __generator2 = function(thisArg, body) {
 var BoundedQueueExportPromiseHandler = (
   /** @class */
   (function() {
-    function BoundedQueueExportPromiseHandler2(concurrencyLimit) {
+    function BoundedQueueExportPromiseHandler3(concurrencyLimit) {
       this._sendingPromises = [];
       this._concurrencyLimit = concurrencyLimit;
     }
-    BoundedQueueExportPromiseHandler2.prototype.pushPromise = function(promise) {
+    BoundedQueueExportPromiseHandler3.prototype.pushPromise = function(promise) {
       var _this = this;
       if (this.hasReachedLimit()) {
         throw new Error("Concurrency Limit reached");
@@ -16888,10 +17050,10 @@ var BoundedQueueExportPromiseHandler = (
       };
       promise.then(popPromise, popPromise);
     };
-    BoundedQueueExportPromiseHandler2.prototype.hasReachedLimit = function() {
+    BoundedQueueExportPromiseHandler3.prototype.hasReachedLimit = function() {
       return this._sendingPromises.length >= this._concurrencyLimit;
     };
-    BoundedQueueExportPromiseHandler2.prototype.awaitAll = function() {
+    BoundedQueueExportPromiseHandler3.prototype.awaitAll = function() {
       return __awaiter2(this, void 0, void 0, function() {
         return __generator2(this, function(_a4) {
           switch (_a4.label) {
@@ -16907,7 +17069,7 @@ var BoundedQueueExportPromiseHandler = (
         });
       });
     };
-    return BoundedQueueExportPromiseHandler2;
+    return BoundedQueueExportPromiseHandler3;
   })()
 );
 function createBoundedQueueExportPromiseHandler(options) {
@@ -17029,7 +17191,7 @@ var __generator3 = function(thisArg, body) {
 var OTLPExportDelegate = (
   /** @class */
   (function() {
-    function OTLPExportDelegate2(_transport, _serializer, _responseHandler, _promiseQueue, _timeout) {
+    function OTLPExportDelegate3(_transport, _serializer, _responseHandler, _promiseQueue, _timeout) {
       this._transport = _transport;
       this._serializer = _serializer;
       this._responseHandler = _responseHandler;
@@ -17039,7 +17201,7 @@ var OTLPExportDelegate = (
         namespace: "OTLPExportDelegate"
       });
     }
-    OTLPExportDelegate2.prototype.export = function(internalRepresentation, resultCallback) {
+    OTLPExportDelegate3.prototype.export = function(internalRepresentation, resultCallback) {
       var _this = this;
       this._diagLogger.debug("items to be sent", internalRepresentation);
       if (this._promiseQueue.hasReachedLimit()) {
@@ -17094,10 +17256,10 @@ var OTLPExportDelegate = (
         });
       }));
     };
-    OTLPExportDelegate2.prototype.forceFlush = function() {
+    OTLPExportDelegate3.prototype.forceFlush = function() {
       return this._promiseQueue.awaitAll();
     };
-    OTLPExportDelegate2.prototype.shutdown = function() {
+    OTLPExportDelegate3.prototype.shutdown = function() {
       return __awaiter3(this, void 0, void 0, function() {
         return __generator3(this, function(_a4) {
           switch (_a4.label) {
@@ -17115,7 +17277,7 @@ var OTLPExportDelegate = (
         });
       });
     };
-    return OTLPExportDelegate2;
+    return OTLPExportDelegate3;
   })()
 );
 function createOtlpExportDelegate(components, settings) {
@@ -17132,21 +17294,21 @@ function createOtlpNetworkExportDelegate(options, serializer, transport) {
 }
 
 // node_modules/@opentelemetry/otlp-transformer/build/esm/common/utils.js
-function hrTimeToNanos(hrTime2) {
+function hrTimeToNanos(hrTime4) {
   var NANOSECONDS = BigInt(1e9);
-  return BigInt(hrTime2[0]) * NANOSECONDS + BigInt(hrTime2[1]);
+  return BigInt(hrTime4[0]) * NANOSECONDS + BigInt(hrTime4[1]);
 }
 function toLongBits(value) {
   var low = Number(BigInt.asUintN(32, value));
   var high = Number(BigInt.asUintN(32, value >> BigInt(32)));
   return { low, high };
 }
-function encodeAsLongBits(hrTime2) {
-  var nanos = hrTimeToNanos(hrTime2);
+function encodeAsLongBits(hrTime4) {
+  var nanos = hrTimeToNanos(hrTime4);
   return toLongBits(nanos);
 }
-function encodeAsString(hrTime2) {
-  var nanos = hrTimeToNanos(hrTime2);
+function encodeAsString(hrTime4) {
+  var nanos = hrTimeToNanos(hrTime4);
   return nanos.toString();
 }
 var encodeTimestamp = typeof BigInt !== "undefined" ? encodeAsString : hrTimeToNanoseconds;
@@ -17433,13 +17595,13 @@ function instrumentationScopeId(instrumentationScope) {
 var TimeoutError = (
   /** @class */
   (function(_super) {
-    __extends4(TimeoutError2, _super);
-    function TimeoutError2(message) {
+    __extends4(TimeoutError3, _super);
+    function TimeoutError3(message) {
       var _this = _super.call(this, message) || this;
-      Object.setPrototypeOf(_this, TimeoutError2.prototype);
+      Object.setPrototypeOf(_this, TimeoutError3.prototype);
       return _this;
     }
-    return TimeoutError2;
+    return TimeoutError3;
   })(Error)
 );
 function callWithTimeout(promise, timeout) {
@@ -22144,10 +22306,10 @@ function getJitter() {
 var RetryingTransport = (
   /** @class */
   (function() {
-    function RetryingTransport2(_transport) {
+    function RetryingTransport3(_transport) {
       this._transport = _transport;
     }
-    RetryingTransport2.prototype.retry = function(data, timeoutMillis, inMillis) {
+    RetryingTransport3.prototype.retry = function(data, timeoutMillis, inMillis) {
       var _this = this;
       return new Promise(function(resolve2, reject) {
         setTimeout(function() {
@@ -22155,7 +22317,7 @@ var RetryingTransport = (
         }, inMillis);
       });
     };
-    RetryingTransport2.prototype.send = function(data, timeoutMillis) {
+    RetryingTransport3.prototype.send = function(data, timeoutMillis) {
       var _a4;
       return __awaiter11(this, void 0, void 0, function() {
         var deadline, result2, attempts, nextBackoff, backoff, retryInMillis, remainingTimeoutMillis;
@@ -22189,10 +22351,10 @@ var RetryingTransport = (
         });
       });
     };
-    RetryingTransport2.prototype.shutdown = function() {
+    RetryingTransport3.prototype.shutdown = function() {
       return this._transport.shutdown();
     };
-    return RetryingTransport2;
+    return RetryingTransport3;
   })()
 );
 function createRetryingTransport(options) {
@@ -22632,6 +22794,217 @@ var OTLPMetricExporter = (
   })(OTLPMetricExporterBase)
 );
 
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/api-logs/build/esm/types/LogRecord.js
+var SeverityNumber2;
+(function(SeverityNumber3) {
+  SeverityNumber3[SeverityNumber3["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  SeverityNumber3[SeverityNumber3["TRACE"] = 1] = "TRACE";
+  SeverityNumber3[SeverityNumber3["TRACE2"] = 2] = "TRACE2";
+  SeverityNumber3[SeverityNumber3["TRACE3"] = 3] = "TRACE3";
+  SeverityNumber3[SeverityNumber3["TRACE4"] = 4] = "TRACE4";
+  SeverityNumber3[SeverityNumber3["DEBUG"] = 5] = "DEBUG";
+  SeverityNumber3[SeverityNumber3["DEBUG2"] = 6] = "DEBUG2";
+  SeverityNumber3[SeverityNumber3["DEBUG3"] = 7] = "DEBUG3";
+  SeverityNumber3[SeverityNumber3["DEBUG4"] = 8] = "DEBUG4";
+  SeverityNumber3[SeverityNumber3["INFO"] = 9] = "INFO";
+  SeverityNumber3[SeverityNumber3["INFO2"] = 10] = "INFO2";
+  SeverityNumber3[SeverityNumber3["INFO3"] = 11] = "INFO3";
+  SeverityNumber3[SeverityNumber3["INFO4"] = 12] = "INFO4";
+  SeverityNumber3[SeverityNumber3["WARN"] = 13] = "WARN";
+  SeverityNumber3[SeverityNumber3["WARN2"] = 14] = "WARN2";
+  SeverityNumber3[SeverityNumber3["WARN3"] = 15] = "WARN3";
+  SeverityNumber3[SeverityNumber3["WARN4"] = 16] = "WARN4";
+  SeverityNumber3[SeverityNumber3["ERROR"] = 17] = "ERROR";
+  SeverityNumber3[SeverityNumber3["ERROR2"] = 18] = "ERROR2";
+  SeverityNumber3[SeverityNumber3["ERROR3"] = 19] = "ERROR3";
+  SeverityNumber3[SeverityNumber3["ERROR4"] = 20] = "ERROR4";
+  SeverityNumber3[SeverityNumber3["FATAL"] = 21] = "FATAL";
+  SeverityNumber3[SeverityNumber3["FATAL2"] = 22] = "FATAL2";
+  SeverityNumber3[SeverityNumber3["FATAL3"] = 23] = "FATAL3";
+  SeverityNumber3[SeverityNumber3["FATAL4"] = 24] = "FATAL4";
+})(SeverityNumber2 || (SeverityNumber2 = {}));
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/api-logs/build/esm/NoopLogger.js
+var NoopLogger2 = class {
+  emit(_logRecord) {
+  }
+};
+var NOOP_LOGGER2 = new NoopLogger2();
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/api-logs/build/esm/internal/global-utils.js
+var GLOBAL_LOGS_API_KEY2 = /* @__PURE__ */ Symbol.for("io.opentelemetry.js.api.logs");
+var _global3 = globalThis;
+function makeGetter2(requiredVersion, instance, fallback) {
+  return (version) => version === requiredVersion ? instance : fallback;
+}
+var API_BACKWARDS_COMPATIBILITY_VERSION2 = 1;
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/api-logs/build/esm/NoopLoggerProvider.js
+var NoopLoggerProvider2 = class {
+  getLogger(_name, _version, _options) {
+    return new NoopLogger2();
+  }
+};
+var NOOP_LOGGER_PROVIDER2 = new NoopLoggerProvider2();
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/api-logs/build/esm/ProxyLogger.js
+var ProxyLogger2 = 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_LOGGER2;
+    }
+    this._delegate = logger;
+    return this._delegate;
+  }
+};
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/api-logs/build/esm/ProxyLoggerProvider.js
+var ProxyLoggerProvider2 = class {
+  getLogger(name, version, options) {
+    var _a4;
+    return (_a4 = this._getDelegateLogger(name, version, options)) !== null && _a4 !== void 0 ? _a4 : new ProxyLogger2(this, name, version, options);
+  }
+  /**
+   * Get the delegate logger provider.
+   * Used by tests only.
+   * @internal
+   */
+  _getDelegate() {
+    var _a4;
+    return (_a4 = this._delegate) !== null && _a4 !== void 0 ? _a4 : NOOP_LOGGER_PROVIDER2;
+  }
+  /**
+   * Set the delegate logger provider
+   * @internal
+   */
+  _setDelegate(delegate) {
+    this._delegate = delegate;
+  }
+  /**
+   * @internal
+   */
+  _getDelegateLogger(name, version, options) {
+    var _a4;
+    return (_a4 = this._delegate) === null || _a4 === void 0 ? void 0 : _a4.getLogger(name, version, options);
+  }
+};
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/api-logs/build/esm/api/logs.js
+var LogsAPI2 = class _LogsAPI {
+  constructor() {
+    this._proxyLoggerProvider = new ProxyLoggerProvider2();
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _LogsAPI();
+    }
+    return this._instance;
+  }
+  setGlobalLoggerProvider(provider) {
+    if (_global3[GLOBAL_LOGS_API_KEY2]) {
+      return this.getLoggerProvider();
+    }
+    _global3[GLOBAL_LOGS_API_KEY2] = makeGetter2(API_BACKWARDS_COMPATIBILITY_VERSION2, provider, NOOP_LOGGER_PROVIDER2);
+    this._proxyLoggerProvider._setDelegate(provider);
+    return provider;
+  }
+  /**
+   * Returns the global logger provider.
+   *
+   * @returns LoggerProvider
+   */
+  getLoggerProvider() {
+    var _a4, _b;
+    return (_b = (_a4 = _global3[GLOBAL_LOGS_API_KEY2]) === null || _a4 === void 0 ? void 0 : _a4.call(_global3, API_BACKWARDS_COMPATIBILITY_VERSION2)) !== 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 _global3[GLOBAL_LOGS_API_KEY2];
+    this._proxyLoggerProvider = new ProxyLoggerProvider2();
+  }
+};
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/api-logs/build/esm/index.js
+var logs2 = LogsAPI2.getInstance();
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
+var SUPPRESS_TRACING_KEY2 = createContextKey("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+function suppressTracing2(context2) {
+  return context2.setValue(SUPPRESS_TRACING_KEY2, true);
+}
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js
+function loggingErrorHandler2() {
+  return (ex) => {
+    diag2.error(stringifyException2(ex));
+  };
+}
+function stringifyException2(ex) {
+  if (typeof ex === "string") {
+    return ex;
+  } else {
+    return JSON.stringify(flattenException2(ex));
+  }
+}
+function flattenException2(ex) {
+  const result2 = {};
+  let current = ex;
+  while (current !== null) {
+    Object.getOwnPropertyNames(current).forEach((propertyName) => {
+      if (result2[propertyName])
+        return;
+      const value = current[propertyName];
+      if (value) {
+        result2[propertyName] = String(value);
+      }
+    });
+    current = Object.getPrototypeOf(current);
+  }
+  return result2;
+}
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js
+var delegateHandler2 = loggingErrorHandler2();
+function globalErrorHandler2(ex) {
+  try {
+    delegateHandler2(ex);
+  } catch {
+  }
+}
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/core/build/esm/version.js
+var VERSION4 = "2.6.1";
+
 // node_modules/@opentelemetry/semantic-conventions/build/esm/trace/SemanticAttributes.js
 var TMP_HTTP_URL = "http.url";
 var TMP_HTTP_USER_AGENT = "http.user_agent";
@@ -22639,140 +23012,1681 @@ var SEMATTRS_HTTP_URL = TMP_HTTP_URL;
 var SEMATTRS_HTTP_USER_AGENT = TMP_HTTP_USER_AGENT;
 
 // node_modules/@opentelemetry/semantic-conventions/build/esm/stable_attributes.js
+var ATTR_EXCEPTION_MESSAGE = "exception.message";
+var ATTR_EXCEPTION_STACKTRACE = "exception.stacktrace";
+var ATTR_EXCEPTION_TYPE = "exception.type";
 var ATTR_SERVICE_NAME = "service.name";
 var ATTR_SERVICE_VERSION = "service.version";
+var ATTR_TELEMETRY_SDK_LANGUAGE = "telemetry.sdk.language";
+var TELEMETRY_SDK_LANGUAGE_VALUE_WEBJS = "webjs";
+var ATTR_TELEMETRY_SDK_NAME = "telemetry.sdk.name";
+var ATTR_TELEMETRY_SDK_VERSION = "telemetry.sdk.version";
 
-// node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/api-logs/build/esm/NoopLogger.js
-var NoopLogger = (
-  /** @class */
-  (function() {
-    function NoopLogger4() {
-    }
-    NoopLogger4.prototype.emit = function(_logRecord) {
-    };
-    return NoopLogger4;
-  })()
-);
-var NOOP_LOGGER = new NoopLogger();
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/core/build/esm/semconv.js
+var ATTR_PROCESS_RUNTIME_NAME = "process.runtime.name";
 
-// node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/api-logs/build/esm/NoopLoggerProvider.js
-var NoopLoggerProvider = (
-  /** @class */
-  (function() {
-    function NoopLoggerProvider4() {
-    }
-    NoopLoggerProvider4.prototype.getLogger = function(_name, _version, _options) {
-      return new NoopLogger();
-    };
-    return NoopLoggerProvider4;
-  })()
-);
-var NOOP_LOGGER_PROVIDER = new NoopLoggerProvider();
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/core/build/esm/platform/browser/sdk-info.js
+var SDK_INFO2 = {
+  [ATTR_TELEMETRY_SDK_NAME]: "opentelemetry",
+  [ATTR_PROCESS_RUNTIME_NAME]: "browser",
+  [ATTR_TELEMETRY_SDK_LANGUAGE]: TELEMETRY_SDK_LANGUAGE_VALUE_WEBJS,
+  [ATTR_TELEMETRY_SDK_VERSION]: VERSION4
+};
 
-// node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/api-logs/build/esm/ProxyLogger.js
-var ProxyLogger = (
-  /** @class */
-  (function() {
-    function ProxyLogger4(_provider, name, version, options) {
-      this._provider = _provider;
-      this.name = name;
-      this.version = version;
-      this.options = options;
-    }
-    ProxyLogger4.prototype.emit = function(logRecord) {
-      this._getLogger().emit(logRecord);
-    };
-    ProxyLogger4.prototype._getLogger = function() {
-      if (this._delegate) {
-        return this._delegate;
-      }
-      var logger = this._provider.getDelegateLogger(this.name, this.version, this.options);
-      if (!logger) {
-        return NOOP_LOGGER;
-      }
-      this._delegate = logger;
-      return this._delegate;
-    };
-    return ProxyLogger4;
-  })()
-);
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/core/build/esm/platform/browser/index.js
+var otperformance2 = performance;
 
-// node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/api-logs/build/esm/ProxyLoggerProvider.js
-var ProxyLoggerProvider = (
-  /** @class */
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/core/build/esm/common/time.js
+var NANOSECOND_DIGITS2 = 9;
+var NANOSECOND_DIGITS_IN_MILLIS2 = 6;
+var MILLISECONDS_TO_NANOSECONDS2 = Math.pow(10, NANOSECOND_DIGITS_IN_MILLIS2);
+var SECOND_TO_NANOSECONDS2 = Math.pow(10, NANOSECOND_DIGITS2);
+function millisToHrTime2(epochMillis) {
+  const epochSeconds = epochMillis / 1e3;
+  const seconds = Math.trunc(epochSeconds);
+  const nanos = Math.round(epochMillis % 1e3 * MILLISECONDS_TO_NANOSECONDS2);
+  return [seconds, nanos];
+}
+function hrTime2(performanceNow) {
+  const timeOrigin = millisToHrTime2(otperformance2.timeOrigin);
+  const now = millisToHrTime2(typeof performanceNow === "number" ? performanceNow : otperformance2.now());
+  return addHrTimes2(timeOrigin, now);
+}
+function timeInputToHrTime2(time) {
+  if (isTimeInputHrTime2(time)) {
+    return time;
+  } else if (typeof time === "number") {
+    if (time < otperformance2.timeOrigin) {
+      return hrTime2(time);
+    } else {
+      return millisToHrTime2(time);
+    }
+  } else if (time instanceof Date) {
+    return millisToHrTime2(time.getTime());
+  } else {
+    throw TypeError("Invalid input type");
+  }
+}
+function isTimeInputHrTime2(value) {
+  return Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number";
+}
+function addHrTimes2(time1, time2) {
+  const out = [time1[0] + time2[0], time1[1] + time2[1]];
+  if (out[1] >= SECOND_TO_NANOSECONDS2) {
+    out[1] -= SECOND_TO_NANOSECONDS2;
+    out[0] += 1;
+  }
+  return out;
+}
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var ExportResultCode2;
+(function(ExportResultCode4) {
+  ExportResultCode4[ExportResultCode4["SUCCESS"] = 0] = "SUCCESS";
+  ExportResultCode4[ExportResultCode4["FAILED"] = 1] = "FAILED";
+})(ExportResultCode2 || (ExportResultCode2 = {}));
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/core/build/esm/utils/timeout.js
+var TimeoutError2 = class _TimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+};
+function callWithTimeout2(promise, timeout) {
+  let timeoutHandle;
+  const timeoutPromise = new Promise(function timeoutFunction(_resolve, reject) {
+    timeoutHandle = setTimeout(function timeoutHandler() {
+      reject(new TimeoutError2("Operation timed out."));
+    }, timeout);
+  });
+  return Promise.race([promise, timeoutPromise]).then((result2) => {
+    clearTimeout(timeoutHandle);
+    return result2;
+  }, (reason) => {
+    clearTimeout(timeoutHandle);
+    throw reason;
+  });
+}
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/core/build/esm/utils/promise.js
+var Deferred2 = class {
+  _promise;
+  _resolve;
+  _reject;
+  constructor() {
+    this._promise = new Promise((resolve2, reject) => {
+      this._resolve = resolve2;
+      this._reject = reject;
+    });
+  }
+  get promise() {
+    return this._promise;
+  }
+  resolve(val) {
+    this._resolve(val);
+  }
+  reject(err) {
+    this._reject(err);
+  }
+};
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/core/build/esm/utils/callback.js
+var BindOnceFuture2 = class {
+  _isCalled = false;
+  _deferred = new Deferred2();
+  _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/sdk-logs/node_modules/@opentelemetry/core/build/esm/internal/exporter.js
+function _export2(exporter, arg) {
+  return new Promise((resolve2) => {
+    context.with(suppressTracing2(context.active()), () => {
+      exporter.export(arg, resolve2);
+    });
+  });
+}
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/core/build/esm/index.js
+var internal2 = {
+  _export: _export2
+};
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/esm/default-service-name.js
+var serviceName;
+function defaultServiceName2() {
+  if (serviceName === void 0) {
+    try {
+      const argv0 = globalThis.process.argv0;
+      serviceName = argv0 ? `unknown_service:${argv0}` : "unknown_service";
+    } catch {
+      serviceName = "unknown_service";
+    }
+  }
+  return serviceName;
+}
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/esm/utils.js
+var isPromiseLike = (val) => {
+  return val !== null && typeof val === "object" && typeof val.then === "function";
+};
+
+// node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/esm/ResourceImpl.js
+var ResourceImpl = class _ResourceImpl {
+  _rawAttributes;
+  _asyncAttributesPending = false;
+  _schemaUrl;
+  _memoizedAttributes;
+  static FromAttributeList(attributes, options) {
+    const res = new _ResourceImpl({}, options);
+    res._rawAttributes = guardedRawAttributes(attributes);
+    res._asyncAttributesPending = attributes.filter(([_, val]) => isPromiseLike(val)).length > 0;
+    return res;
+  }
+  constructor(resource, options) {
+    const attributes = resource.attributes ?? {};
+    this._rawAttributes = Object.entries(attributes).map(([k, v]) => {
+      if (isPromiseLike(v)) {
+        this._asyncAttributesPending = true;
+      }
+      return [k, v];
+    });
+    this._rawAttributes = guardedRawAttributes(this._rawAttributes);
+    this._schemaUrl = validateSchemaUrl(options?.schemaUrl);
+  }
+  get asyncAttributesPending() {
+    return this._asyncAttributesPending;
+  }
+  async waitForAsyncAttributes() {
+    if (!this.asyncAttributesPending) {
+      return;
+    }
+    for (let i = 0; i < this._rawAttributes.length; i++) {
+      const [k, v] = this._rawAttributes[i];
+      this._rawAttributes[i] = [k, isPromiseLike(v) ? await v : v];
+    }
+    this._asyncAttributesPending = false;
+  }
+  get attributes() {
+    if (this.asyncAttributesPending) {
+      diag2.error("Accessing resource attributes before async attributes settled");
+    }
+    if (this._memoizedAttributes) {
+      return this._memoizedAttributes;
+    }
+    const attrs = {};
+    for (const [k, v] of this._rawAttributes) {
+      if (isPromiseLike(v)) {
+        diag2.debug(`Unsettled resource attribute ${k} skipped`);
+        continue;
+      }
+      if (v != null) {
+        attrs[k] ??= v;
+      }
+    }
+    if (!this._asyncAttributesPending) {
+      this._memoizedAttributes = attrs;
+    }
+    return attrs;
+  }
+  getRawAttributes() {
+    return this._rawAttributes;
+  }
+  get schemaUrl() {
+    return this._schemaUrl;
+  }
+  merge(resource) {
+    if (resource == null)
+      return this;
+    const mergedSchemaUrl = mergeSchemaUrl(this, resource);
+    const mergedOptions = mergedSchemaUrl ? { schemaUrl: mergedSchemaUrl } : void 0;
+    return _ResourceImpl.FromAttributeList([...resource.getRawAttributes(), ...this.getRawAttributes()], mergedOptions);
+  }
+};
+function resourceFromAttributes(attributes, options) {
+  return ResourceImpl.FromAttributeList(Object.entries(attributes), options);
+}
+function defaultResource() {
+  return resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: defaultServiceName2(),
+    [ATTR_TELEMETRY_SDK_LANGUAGE]: SDK_INFO2[ATTR_TELEMETRY_SDK_LANGUAGE],
+    [ATTR_TELEMETRY_SDK_NAME]: SDK_INFO2[ATTR_TELEMETRY_SDK_NAME],
+    [ATTR_TELEMETRY_SDK_VERSION]: SDK_INFO2[ATTR_TELEMETRY_SDK_VERSION]
+  });
+}
+function guardedRawAttributes(attributes) {
+  return attributes.map(([k, v]) => {
+    if (isPromiseLike(v)) {
+      return [
+        k,
+        v.catch((err) => {
+          diag2.debug("promise rejection for resource attribute: %s - %s", k, err);
+          return void 0;
+        })
+      ];
+    }
+    return [k, v];
+  });
+}
+function validateSchemaUrl(schemaUrl) {
+  if (typeof schemaUrl === "string" || schemaUrl === void 0) {
+    return schemaUrl;
+  }
+  diag2.warn("Schema URL must be string or undefined, got %s. Schema URL will be ignored.", schemaUrl);
+  return void 0;
+}
+function mergeSchemaUrl(old, updating) {
+  const oldSchemaUrl = old?.schemaUrl;
+  const updatingSchemaUrl = updating?.schemaUrl;
+  const isOldEmpty = oldSchemaUrl === void 0 || oldSchemaUrl === "";
+  const isUpdatingEmpty = updatingSchemaUrl === void 0 || updatingSchemaUrl === "";
+  if (isOldEmpty) {
+    return updatingSchemaUrl;
+  }
+  if (isUpdatingEmpty) {
+    return oldSchemaUrl;
+  }
+  if (oldSchemaUrl === updatingSchemaUrl) {
+    return oldSchemaUrl;
+  }
+  diag2.warn('Schema URL merge conflict: old resource has "%s", updating resource has "%s". Resulting resource will have undefined Schema URL.', oldSchemaUrl, updatingSchemaUrl);
+  return void 0;
+}
+
+// node_modules/@opentelemetry/sdk-logs/build/esm/utils/validation.js
+function isLogAttributeValue(val) {
+  return isLogAttributeValueInternal(val, /* @__PURE__ */ new WeakSet());
+}
+function isLogAttributeValueInternal(val, visited) {
+  if (val == null) {
+    return true;
+  }
+  if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
+    return true;
+  }
+  if (val instanceof Uint8Array) {
+    return true;
+  }
+  if (typeof val === "object") {
+    if (visited.has(val)) {
+      return false;
+    }
+    visited.add(val);
+    if (Array.isArray(val)) {
+      return val.every((item) => isLogAttributeValueInternal(item, visited));
+    }
+    const obj = val;
+    if (obj.constructor !== Object && obj.constructor !== void 0) {
+      return false;
+    }
+    return Object.values(obj).every((item) => isLogAttributeValueInternal(item, visited));
+  }
+  return false;
+}
+
+// node_modules/@opentelemetry/sdk-logs/build/esm/LogRecordImpl.js
+var LogRecordImpl = class {
+  hrTime;
+  hrTimeObserved;
+  spanContext;
+  resource;
+  instrumentationScope;
+  attributes = {};
+  _severityText;
+  _severityNumber;
+  _body;
+  _eventName;
+  _attributesCount = 0;
+  _droppedAttributesCount = 0;
+  _isReadonly = false;
+  _logRecordLimits;
+  set severityText(severityText) {
+    if (this._isLogRecordReadonly()) {
+      return;
+    }
+    this._severityText = severityText;
+  }
+  get severityText() {
+    return this._severityText;
+  }
+  set severityNumber(severityNumber) {
+    if (this._isLogRecordReadonly()) {
+      return;
+    }
+    this._severityNumber = severityNumber;
+  }
+  get severityNumber() {
+    return this._severityNumber;
+  }
+  set body(body) {
+    if (this._isLogRecordReadonly()) {
+      return;
+    }
+    this._body = body;
+  }
+  get body() {
+    return this._body;
+  }
+  get eventName() {
+    return this._eventName;
+  }
+  set eventName(eventName) {
+    if (this._isLogRecordReadonly()) {
+      return;
+    }
+    this._eventName = eventName;
+  }
+  get droppedAttributesCount() {
+    return this._droppedAttributesCount;
+  }
+  constructor(_sharedState, instrumentationScope, logRecord) {
+    const { timestamp, observedTimestamp, eventName, severityNumber, severityText, body, attributes = {}, exception, context: context2 } = logRecord;
+    const now = Date.now();
+    this.hrTime = timeInputToHrTime2(timestamp ?? now);
+    this.hrTimeObserved = timeInputToHrTime2(observedTimestamp ?? now);
+    if (context2) {
+      const spanContext = trace.getSpanContext(context2);
+      if (spanContext && isSpanContextValid(spanContext)) {
+        this.spanContext = spanContext;
+      }
+    }
+    this.severityNumber = severityNumber;
+    this.severityText = severityText;
+    this.body = body;
+    this.resource = _sharedState.resource;
+    this.instrumentationScope = instrumentationScope;
+    this._logRecordLimits = _sharedState.logRecordLimits;
+    this._eventName = eventName;
+    this.setAttributes(attributes);
+    if (exception != null) {
+      this._setException(exception);
+    }
+  }
+  setAttribute(key, value) {
+    if (this._isLogRecordReadonly()) {
+      return this;
+    }
+    if (key.length === 0) {
+      diag2.warn(`Invalid attribute key: ${key}`);
+      return this;
+    }
+    if (!isLogAttributeValue(value)) {
+      diag2.warn(`Invalid attribute value set for key: ${key}`);
+      return this;
+    }
+    const isNewKey = !Object.prototype.hasOwnProperty.call(this.attributes, key);
+    if (isNewKey && this._attributesCount >= this._logRecordLimits.attributeCountLimit) {
+      this._droppedAttributesCount++;
+      if (this._droppedAttributesCount === 1) {
+        diag2.warn("Dropping extra attributes.");
+      }
+      return this;
+    }
+    this.attributes[key] = this._truncateToSize(value);
+    if (isNewKey) {
+      this._attributesCount++;
+    }
+    return this;
+  }
+  setAttributes(attributes) {
+    for (const [k, v] of Object.entries(attributes)) {
+      this.setAttribute(k, v);
+    }
+    return this;
+  }
+  setBody(body) {
+    this.body = body;
+    return this;
+  }
+  setEventName(eventName) {
+    this.eventName = eventName;
+    return this;
+  }
+  setSeverityNumber(severityNumber) {
+    this.severityNumber = severityNumber;
+    return this;
+  }
+  setSeverityText(severityText) {
+    this.severityText = severityText;
+    return this;
+  }
+  /**
+   * @internal
+   * A LogRecordProcessor may freely modify logRecord for the duration of the OnEmit call.
+   * If logRecord is needed after OnEmit returns (i.e. for asynchronous processing) only reads are permitted.
+   */
+  _makeReadonly() {
+    this._isReadonly = true;
+  }
+  _truncateToSize(value) {
+    const limit = this._logRecordLimits.attributeValueLengthLimit;
+    if (limit <= 0) {
+      diag2.warn(`Attribute value limit must be positive, got ${limit}`);
+      return value;
+    }
+    if (value == null) {
+      return value;
+    }
+    if (typeof value === "string") {
+      return this._truncateToLimitUtil(value, limit);
+    }
+    if (value instanceof Uint8Array) {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((val) => this._truncateToSize(val));
+    }
+    if (typeof value === "object") {
+      const truncatedObj = {};
+      for (const [k, v] of Object.entries(value)) {
+        truncatedObj[k] = this._truncateToSize(v);
+      }
+      return truncatedObj;
+    }
+    return value;
+  }
+  _setException(exception) {
+    let hasMinimumAttributes = false;
+    if (typeof exception === "string" || typeof exception === "number") {
+      if (!Object.hasOwn(this.attributes, ATTR_EXCEPTION_MESSAGE)) {
+        this.setAttribute(ATTR_EXCEPTION_MESSAGE, String(exception));
+      }
+      hasMinimumAttributes = true;
+    } else if (exception && typeof exception === "object") {
+      const exceptionObj = exception;
+      if (exceptionObj.code) {
+        if (!Object.hasOwn(this.attributes, ATTR_EXCEPTION_TYPE)) {
+          this.setAttribute(ATTR_EXCEPTION_TYPE, exceptionObj.code.toString());
+        }
+        hasMinimumAttributes = true;
+      } else if (exceptionObj.name) {
+        if (!Object.hasOwn(this.attributes, ATTR_EXCEPTION_TYPE)) {
+          this.setAttribute(ATTR_EXCEPTION_TYPE, exceptionObj.name);
+        }
+        hasMinimumAttributes = true;
+      }
+      if (exceptionObj.message) {
+        if (!Object.hasOwn(this.attributes, ATTR_EXCEPTION_MESSAGE)) {
+          this.setAttribute(ATTR_EXCEPTION_MESSAGE, exceptionObj.message);
+        }
+        hasMinimumAttributes = true;
+      }
+      if (exceptionObj.stack) {
+        if (!Object.hasOwn(this.attributes, ATTR_EXCEPTION_STACKTRACE)) {
+          this.setAttribute(ATTR_EXCEPTION_STACKTRACE, exceptionObj.stack);
+        }
+        hasMinimumAttributes = true;
+      }
+    }
+    if (!hasMinimumAttributes) {
+      diag2.warn(`Failed to record an exception ${exception}`);
+    }
+  }
+  _truncateToLimitUtil(value, limit) {
+    if (value.length <= limit) {
+      return value;
+    }
+    return value.substring(0, limit);
+  }
+  _isLogRecordReadonly() {
+    if (this._isReadonly) {
+      diag2.warn("Can not execute the operation on emitted log record");
+    }
+    return this._isReadonly;
+  }
+};
+
+// node_modules/@opentelemetry/sdk-logs/build/esm/Logger.js
+var Logger = class {
+  instrumentationScope;
+  _sharedState;
+  _loggerConfig;
+  constructor(instrumentationScope, sharedState) {
+    this.instrumentationScope = instrumentationScope;
+    this._sharedState = sharedState;
+    this._loggerConfig = this._sharedState.getLoggerConfig(this.instrumentationScope);
+  }
+  emit(logRecord) {
+    const loggerConfig = this._loggerConfig;
+    const currentContext = logRecord.context || context.active();
+    const recordSeverity = logRecord.severityNumber ?? SeverityNumber2.UNSPECIFIED;
+    if (recordSeverity !== SeverityNumber2.UNSPECIFIED && recordSeverity < loggerConfig.minimumSeverity) {
+      return;
+    }
+    if (loggerConfig.traceBased) {
+      const spanContext = trace.getSpanContext(currentContext);
+      if (spanContext && isSpanContextValid(spanContext)) {
+        const isSampled = (spanContext.traceFlags & TraceFlags.SAMPLED) === TraceFlags.SAMPLED;
+        if (!isSampled) {
+          return;
+        }
+      }
+    }
+    const logRecordInstance = new LogRecordImpl(this._sharedState, this.instrumentationScope, {
+      context: currentContext,
+      ...logRecord
+    });
+    this._sharedState.activeProcessor.onEmit(logRecordInstance, currentContext);
+    logRecordInstance._makeReadonly();
+  }
+};
+
+// node_modules/@opentelemetry/sdk-logs/build/esm/export/NoopLogRecordProcessor.js
+var NoopLogRecordProcessor = class {
+  forceFlush() {
+    return Promise.resolve();
+  }
+  onEmit(_logRecord, _context) {
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+};
+
+// node_modules/@opentelemetry/sdk-logs/build/esm/MultiLogRecordProcessor.js
+var MultiLogRecordProcessor = class {
+  processors;
+  forceFlushTimeoutMillis;
+  constructor(processors, forceFlushTimeoutMillis) {
+    this.processors = processors;
+    this.forceFlushTimeoutMillis = forceFlushTimeoutMillis;
+  }
+  async forceFlush() {
+    const timeout = this.forceFlushTimeoutMillis;
+    await Promise.all(this.processors.map((processor2) => callWithTimeout2(processor2.forceFlush(), timeout)));
+  }
+  onEmit(logRecord, context2) {
+    this.processors.forEach((processors) => processors.onEmit(logRecord, context2));
+  }
+  async shutdown() {
+    await Promise.all(this.processors.map((processor2) => processor2.shutdown()));
+  }
+};
+
+// node_modules/@opentelemetry/sdk-logs/build/esm/internal/utils.js
+function getInstrumentationScopeKey(scope) {
+  return `${scope.name}@${scope.version || ""}:${scope.schemaUrl || ""}`;
+}
+
+// node_modules/@opentelemetry/sdk-logs/build/esm/internal/LoggerProviderSharedState.js
+var DEFAULT_LOGGER_CONFIG = {
+  disabled: false,
+  minimumSeverity: SeverityNumber2.UNSPECIFIED,
+  traceBased: false
+};
+var DEFAULT_LOGGER_CONFIGURATOR = () => ({
+  ...DEFAULT_LOGGER_CONFIG
+});
+var LoggerProviderSharedState = class {
+  loggers = /* @__PURE__ */ new Map();
+  activeProcessor;
+  registeredLogRecordProcessors = [];
+  resource;
+  forceFlushTimeoutMillis;
+  logRecordLimits;
+  processors;
+  _loggerConfigurator;
+  _loggerConfigs = /* @__PURE__ */ new Map();
+  constructor(resource, forceFlushTimeoutMillis, logRecordLimits, processors, loggerConfigurator) {
+    this.resource = resource;
+    this.forceFlushTimeoutMillis = forceFlushTimeoutMillis;
+    this.logRecordLimits = logRecordLimits;
+    this.processors = processors;
+    if (processors.length > 0) {
+      this.registeredLogRecordProcessors = processors;
+      this.activeProcessor = new MultiLogRecordProcessor(this.registeredLogRecordProcessors, this.forceFlushTimeoutMillis);
+    } else {
+      this.activeProcessor = new NoopLogRecordProcessor();
+    }
+    this._loggerConfigurator = loggerConfigurator ?? DEFAULT_LOGGER_CONFIGURATOR;
+  }
+  /**
+   * Get the LoggerConfig for a given instrumentation scope.
+   * Uses the LoggerConfigurator function to compute the config on first access
+   * and caches the result.
+   *
+   * @experimental This feature is in development as per the OpenTelemetry specification.
+   */
+  getLoggerConfig(instrumentationScope) {
+    const key = getInstrumentationScopeKey(instrumentationScope);
+    let config = this._loggerConfigs.get(key);
+    if (config) {
+      return config;
+    }
+    config = this._loggerConfigurator(instrumentationScope);
+    this._loggerConfigs.set(key, config);
+    return config;
+  }
+};
+
+// node_modules/@opentelemetry/sdk-logs/build/esm/LoggerProvider.js
+var DEFAULT_LOGGER_NAME = "unknown";
+var LoggerProvider = class {
+  _shutdownOnce;
+  _sharedState;
+  constructor(config = {}) {
+    const mergedConfig = {
+      resource: config.resource ?? defaultResource(),
+      forceFlushTimeoutMillis: config.forceFlushTimeoutMillis ?? 3e4,
+      logRecordLimits: {
+        attributeCountLimit: config.logRecordLimits?.attributeCountLimit ?? 128,
+        attributeValueLengthLimit: config.logRecordLimits?.attributeValueLengthLimit ?? Infinity
+      },
+      loggerConfigurator: config.loggerConfigurator ?? DEFAULT_LOGGER_CONFIGURATOR,
+      processors: config.processors ?? []
+    };
+    this._sharedState = new LoggerProviderSharedState(mergedConfig.resource, mergedConfig.forceFlushTimeoutMillis, mergedConfig.logRecordLimits, mergedConfig.processors, mergedConfig.loggerConfigurator);
+    this._shutdownOnce = new BindOnceFuture2(this._shutdown, this);
+  }
+  /**
+   * Get a logger with the configuration of the LoggerProvider.
+   */
+  getLogger(name, version, options) {
+    if (this._shutdownOnce.isCalled) {
+      diag2.warn("A shutdown LoggerProvider cannot provide a Logger");
+      return NOOP_LOGGER2;
+    }
+    if (!name) {
+      diag2.warn("Logger requested without instrumentation scope name.");
+    }
+    const loggerName = name || DEFAULT_LOGGER_NAME;
+    const key = `${loggerName}@${version || ""}:${options?.schemaUrl || ""}`;
+    if (!this._sharedState.loggers.has(key)) {
+      this._sharedState.loggers.set(key, new Logger({ name: loggerName, version, schemaUrl: options?.schemaUrl }, this._sharedState));
+    }
+    return this._sharedState.loggers.get(key);
+  }
+  /**
+   * Notifies all registered LogRecordProcessor to flush any buffered data.
+   *
+   * Returns a promise which is resolved when all flushes are complete.
+   */
+  forceFlush() {
+    if (this._shutdownOnce.isCalled) {
+      diag2.warn("invalid attempt to force flush after LoggerProvider shutdown");
+      return this._shutdownOnce.promise;
+    }
+    return this._sharedState.activeProcessor.forceFlush();
+  }
+  /**
+   * Flush all buffered data and shut down the LoggerProvider and all registered
+   * LogRecordProcessor.
+   *
+   * Returns a promise which is resolved when all flushes are complete.
+   */
+  shutdown() {
+    if (this._shutdownOnce.isCalled) {
+      diag2.warn("shutdown may only be called once per LoggerProvider");
+      return this._shutdownOnce.promise;
+    }
+    return this._shutdownOnce.call();
+  }
+  _shutdown() {
+    return this._sharedState.activeProcessor.shutdown();
+  }
+};
+
+// node_modules/@opentelemetry/sdk-logs/build/esm/export/BatchLogRecordProcessorBase.js
+var BatchLogRecordProcessorBase = class {
+  _maxExportBatchSize;
+  _maxQueueSize;
+  _scheduledDelayMillis;
+  _exportTimeoutMillis;
+  _exporter;
+  _isExporting = false;
+  _finishedLogRecords = [];
+  _timer;
+  _shutdownOnce;
+  constructor(exporter, config) {
+    this._exporter = exporter;
+    this._maxExportBatchSize = config?.maxExportBatchSize ?? 512;
+    this._maxQueueSize = config?.maxQueueSize ?? 2048;
+    this._scheduledDelayMillis = config?.scheduledDelayMillis ?? 5e3;
+    this._exportTimeoutMillis = config?.exportTimeoutMillis ?? 3e4;
+    this._shutdownOnce = new BindOnceFuture2(this._shutdown, this);
+    if (this._maxExportBatchSize > this._maxQueueSize) {
+      diag2.warn("BatchLogRecordProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize");
+      this._maxExportBatchSize = this._maxQueueSize;
+    }
+  }
+  onEmit(logRecord) {
+    if (this._shutdownOnce.isCalled) {
+      return;
+    }
+    this._addToBuffer(logRecord);
+  }
+  forceFlush() {
+    if (this._shutdownOnce.isCalled) {
+      return this._shutdownOnce.promise;
+    }
+    return this._flushAll();
+  }
+  shutdown() {
+    return this._shutdownOnce.call();
+  }
+  async _shutdown() {
+    this.onShutdown();
+    await this._flushAll();
+    await this._exporter.shutdown();
+  }
+  /** Add a LogRecord in the buffer. */
+  _addToBuffer(logRecord) {
+    if (this._finishedLogRecords.length >= this._maxQueueSize) {
+      return;
+    }
+    this._finishedLogRecords.push(logRecord);
+    this._maybeStartTimer();
+  }
+  /**
+   * Send all LogRecords 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((resolve2, reject) => {
+      const promises = [];
+      const batchCount = Math.ceil(this._finishedLogRecords.length / this._maxExportBatchSize);
+      for (let i = 0; i < batchCount; i++) {
+        promises.push(this._flushOneBatch());
+      }
+      Promise.all(promises).then(() => {
+        resolve2();
+      }).catch(reject);
+    });
+  }
+  _flushOneBatch() {
+    this._clearTimer();
+    if (this._finishedLogRecords.length === 0) {
+      return Promise.resolve();
+    }
+    return callWithTimeout2(this._export(this._finishedLogRecords.splice(0, this._maxExportBatchSize)), this._exportTimeoutMillis);
+  }
+  _maybeStartTimer() {
+    if (this._isExporting)
+      return;
+    const flush = () => {
+      this._isExporting = true;
+      this._flushOneBatch().then(() => {
+        this._isExporting = false;
+        if (this._finishedLogRecords.length > 0) {
+          this._clearTimer();
+          this._maybeStartTimer();
+        }
+      }).catch((e) => {
+        this._isExporting = false;
+        globalErrorHandler2(e);
+      });
+    };
+    if (this._finishedLogRecords.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;
+    }
+  }
+  _export(logRecords) {
+    const doExport = () => internal2._export(this._exporter, logRecords).then((result2) => {
+      if (result2.code !== ExportResultCode2.SUCCESS) {
+        globalErrorHandler2(result2.error ?? new Error(`BatchLogRecordProcessor: log record export failed (status ${result2})`));
+      }
+    }).catch(globalErrorHandler2);
+    const pendingResources = [];
+    for (let i = 0; i < logRecords.length; i++) {
+      const resource = logRecords[i].resource;
+      if (resource.asyncAttributesPending && typeof resource.waitForAsyncAttributes === "function") {
+        pendingResources.push(resource.waitForAsyncAttributes());
+      }
+    }
+    if (pendingResources.length === 0) {
+      return doExport();
+    } else {
+      return Promise.all(pendingResources).then(doExport, globalErrorHandler2);
+    }
+  }
+};
+
+// node_modules/@opentelemetry/sdk-logs/build/esm/platform/browser/export/BatchLogRecordProcessor.js
+var BatchLogRecordProcessor = class extends BatchLogRecordProcessorBase {
+  _visibilityChangeListener;
+  _pageHideListener;
+  constructor(exporter, config) {
+    super(exporter, config);
+    this._onInit(config);
+  }
+  onShutdown() {
+    if (typeof document === "undefined") {
+      return;
+    }
+    if (this._visibilityChangeListener) {
+      document.removeEventListener("visibilitychange", this._visibilityChangeListener);
+    }
+    if (this._pageHideListener) {
+      document.removeEventListener("pagehide", this._pageHideListener);
+    }
+  }
+  _onInit(config) {
+    if (config?.disableAutoFlushOnDocumentHide === true || typeof document === "undefined") {
+      return;
+    }
+    this._visibilityChangeListener = () => {
+      if (document.visibilityState === "hidden") {
+        void this.forceFlush();
+      }
+    };
+    this._pageHideListener = () => {
+      void this.forceFlush();
+    };
+    document.addEventListener("visibilitychange", this._visibilityChangeListener);
+    document.addEventListener("pagehide", this._pageHideListener);
+  }
+};
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/OTLPExporterBase.js
+var OTLPExporterBase2 = class {
+  _delegate;
+  constructor(delegate) {
+    this._delegate = delegate;
+  }
+  /**
+   * Export items.
+   * @param items
+   * @param resultCallback
+   */
+  export(items, resultCallback) {
+    this._delegate.export(items, resultCallback);
+  }
+  forceFlush() {
+    return this._delegate.forceFlush();
+  }
+  shutdown() {
+    return this._delegate.shutdown();
+  }
+};
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/types.js
+var OTLPExporterError2 = class extends Error {
+  code;
+  name = "OTLPExporterError";
+  data;
+  constructor(message, code, data) {
+    super(message);
+    this.data = data;
+    this.code = code;
+  }
+};
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-configuration.js
+function validateTimeoutMillis2(timeoutMillis) {
+  if (Number.isFinite(timeoutMillis) && timeoutMillis > 0) {
+    return timeoutMillis;
+  }
+  throw new Error(`Configuration: timeoutMillis is invalid, expected number greater than 0 (actual: '${timeoutMillis}')`);
+}
+function wrapStaticHeadersInFunction2(headers) {
+  if (headers == null) {
+    return void 0;
+  }
+  return async () => headers;
+}
+function mergeOtlpSharedConfigurationWithDefaults2(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
+  return {
+    timeoutMillis: validateTimeoutMillis2(userProvidedConfiguration.timeoutMillis ?? fallbackConfiguration.timeoutMillis ?? defaultConfiguration.timeoutMillis),
+    concurrencyLimit: userProvidedConfiguration.concurrencyLimit ?? fallbackConfiguration.concurrencyLimit ?? defaultConfiguration.concurrencyLimit,
+    compression: userProvidedConfiguration.compression ?? fallbackConfiguration.compression ?? defaultConfiguration.compression
+  };
+}
+function getSharedConfigurationDefaults2() {
+  return {
+    timeoutMillis: 1e4,
+    concurrencyLimit: 30,
+    compression: "none"
+  };
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/bounded-queue-export-promise-handler.js
+var BoundedQueueExportPromiseHandler2 = class {
+  _concurrencyLimit;
+  _sendingPromises = [];
+  /**
+   * @param concurrencyLimit maximum promises allowed in a queue at the same time.
+   */
+  constructor(concurrencyLimit) {
+    this._concurrencyLimit = concurrencyLimit;
+  }
+  pushPromise(promise) {
+    if (this.hasReachedLimit()) {
+      throw new Error("Concurrency Limit reached");
+    }
+    this._sendingPromises.push(promise);
+    const popPromise = () => {
+      const index2 = this._sendingPromises.indexOf(promise);
+      void this._sendingPromises.splice(index2, 1);
+    };
+    promise.then(popPromise, popPromise);
+  }
+  hasReachedLimit() {
+    return this._sendingPromises.length >= this._concurrencyLimit;
+  }
+  async awaitAll() {
+    await Promise.all(this._sendingPromises);
+  }
+};
+function createBoundedQueueExportPromiseHandler2(options) {
+  return new BoundedQueueExportPromiseHandler2(options.concurrencyLimit);
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/core/build/esm/common/time.js
+var NANOSECOND_DIGITS3 = 9;
+var NANOSECOND_DIGITS_IN_MILLIS3 = 6;
+var MILLISECONDS_TO_NANOSECONDS3 = Math.pow(10, NANOSECOND_DIGITS_IN_MILLIS3);
+var SECOND_TO_NANOSECONDS3 = Math.pow(10, NANOSECOND_DIGITS3);
+function hrTimeToNanoseconds3(time) {
+  return time[0] * SECOND_TO_NANOSECONDS3 + time[1];
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var ExportResultCode3;
+(function(ExportResultCode4) {
+  ExportResultCode4[ExportResultCode4["SUCCESS"] = 0] = "SUCCESS";
+  ExportResultCode4[ExportResultCode4["FAILED"] = 1] = "FAILED";
+})(ExportResultCode3 || (ExportResultCode3 = {}));
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/logging-response-handler.js
+function isPartialSuccessResponse2(response) {
+  return Object.prototype.hasOwnProperty.call(response, "partialSuccess");
+}
+function createLoggingPartialSuccessResponseHandler2() {
+  return {
+    handleResponse(response) {
+      if (response == null || !isPartialSuccessResponse2(response) || response.partialSuccess == null || Object.keys(response.partialSuccess).length === 0) {
+        return;
+      }
+      diag2.warn("Received Partial Success response:", JSON.stringify(response.partialSuccess));
+    }
+  };
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-export-delegate.js
+var OTLPExportDelegate2 = class {
+  _diagLogger;
+  _transport;
+  _serializer;
+  _responseHandler;
+  _promiseQueue;
+  _timeout;
+  constructor(transport, serializer, responseHandler, promiseQueue, timeout) {
+    this._transport = transport;
+    this._serializer = serializer;
+    this._responseHandler = responseHandler;
+    this._promiseQueue = promiseQueue;
+    this._timeout = timeout;
+    this._diagLogger = diag2.createComponentLogger({
+      namespace: "OTLPExportDelegate"
+    });
+  }
+  export(internalRepresentation, resultCallback) {
+    this._diagLogger.debug("items to be sent", internalRepresentation);
+    if (this._promiseQueue.hasReachedLimit()) {
+      resultCallback({
+        code: ExportResultCode3.FAILED,
+        error: new Error("Concurrent export limit reached")
+      });
+      return;
+    }
+    const serializedRequest = this._serializer.serializeRequest(internalRepresentation);
+    if (serializedRequest == null) {
+      resultCallback({
+        code: ExportResultCode3.FAILED,
+        error: new Error("Nothing to send")
+      });
+      return;
+    }
+    this._promiseQueue.pushPromise(this._transport.send(serializedRequest, this._timeout).then((response) => {
+      if (response.status === "success") {
+        if (response.data != null) {
+          try {
+            this._responseHandler.handleResponse(this._serializer.deserializeResponse(response.data));
+          } catch (e) {
+            this._diagLogger.warn("Export succeeded but could not deserialize response - is the response specification compliant?", e, response.data);
+          }
+        }
+        resultCallback({
+          code: ExportResultCode3.SUCCESS
+        });
+        return;
+      } else if (response.status === "failure" && response.error) {
+        resultCallback({
+          code: ExportResultCode3.FAILED,
+          error: response.error
+        });
+        return;
+      } else if (response.status === "retryable") {
+        resultCallback({
+          code: ExportResultCode3.FAILED,
+          error: response.error ?? new OTLPExporterError2("Export failed with retryable status")
+        });
+      } else {
+        resultCallback({
+          code: ExportResultCode3.FAILED,
+          error: new OTLPExporterError2("Export failed with unknown error")
+        });
+      }
+    }, (reason) => resultCallback({
+      code: ExportResultCode3.FAILED,
+      error: reason
+    })));
+  }
+  forceFlush() {
+    return this._promiseQueue.awaitAll();
+  }
+  async shutdown() {
+    this._diagLogger.debug("shutdown started");
+    await this.forceFlush();
+    this._transport.shutdown();
+  }
+};
+function createOtlpExportDelegate2(components, settings) {
+  return new OTLPExportDelegate2(components.transport, components.serializer, createLoggingPartialSuccessResponseHandler2(), components.promiseHandler, settings.timeout);
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-network-export-delegate.js
+function createOtlpNetworkExportDelegate2(options, serializer, transport) {
+  return createOtlpExportDelegate2({
+    transport,
+    serializer,
+    promiseHandler: createBoundedQueueExportPromiseHandler2(options)
+  }, { timeout: options.timeoutMillis });
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-transformer/build/esm/common/internal.js
+function createResource2(resource, encoder) {
+  const result2 = {
+    attributes: toAttributes2(resource.attributes, encoder),
+    droppedAttributesCount: 0
+  };
+  const schemaUrl = resource.schemaUrl;
+  if (schemaUrl && schemaUrl !== "")
+    result2.schemaUrl = schemaUrl;
+  return result2;
+}
+function createInstrumentationScope2(scope) {
+  return {
+    name: scope.name,
+    version: scope.version
+  };
+}
+function toAttributes2(attributes, encoder) {
+  return Object.keys(attributes).map((key) => toKeyValue2(key, attributes[key], encoder));
+}
+function toKeyValue2(key, value, encoder) {
+  return {
+    key,
+    value: toAnyValue2(value, encoder)
+  };
+}
+function toAnyValue2(value, encoder) {
+  const t = typeof value;
+  if (t === "string")
+    return { stringValue: value };
+  if (t === "number") {
+    if (!Number.isInteger(value))
+      return { doubleValue: value };
+    return { intValue: value };
+  }
+  if (t === "boolean")
+    return { boolValue: value };
+  if (value instanceof Uint8Array)
+    return { bytesValue: encoder.encodeUint8Array(value) };
+  if (Array.isArray(value)) {
+    const values = new Array(value.length);
+    for (let i = 0; i < value.length; i++) {
+      values[i] = toAnyValue2(value[i], encoder);
+    }
+    return { arrayValue: { values } };
+  }
+  if (t === "object" && value != null) {
+    const keys = Object.keys(value);
+    const values = new Array(keys.length);
+    for (let i = 0; i < keys.length; i++) {
+      values[i] = {
+        key: keys[i],
+        value: toAnyValue2(value[keys[i]], encoder)
+      };
+    }
+    return { kvlistValue: { values } };
+  }
+  return {};
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-transformer/build/esm/logs/internal.js
+function createExportLogsServiceRequest(logRecords, encoder) {
+  return {
+    resourceLogs: logRecordsToResourceLogs(logRecords, encoder)
+  };
+}
+function createResourceMap2(logRecords) {
+  const resourceMap = /* @__PURE__ */ new Map();
+  for (const record2 of logRecords) {
+    const { resource, instrumentationScope: { name, version = "", schemaUrl = "" } } = record2;
+    let ismMap = resourceMap.get(resource);
+    if (!ismMap) {
+      ismMap = /* @__PURE__ */ new Map();
+      resourceMap.set(resource, ismMap);
+    }
+    const ismKey = `${name}@${version}:${schemaUrl}`;
+    let records = ismMap.get(ismKey);
+    if (!records) {
+      records = [];
+      ismMap.set(ismKey, records);
+    }
+    records.push(record2);
+  }
+  return resourceMap;
+}
+function logRecordsToResourceLogs(logRecords, encoder) {
+  const resourceMap = createResourceMap2(logRecords);
+  return Array.from(resourceMap, ([resource, ismMap]) => {
+    const processedResource = createResource2(resource, encoder);
+    return {
+      resource: processedResource,
+      scopeLogs: Array.from(ismMap, ([, scopeLogs]) => {
+        return {
+          scope: createInstrumentationScope2(scopeLogs[0].instrumentationScope),
+          logRecords: scopeLogs.map((log) => toLogRecord(log, encoder)),
+          schemaUrl: scopeLogs[0].instrumentationScope.schemaUrl
+        };
+      }),
+      schemaUrl: processedResource.schemaUrl
+    };
+  });
+}
+function toLogRecord(log, encoder) {
+  return {
+    timeUnixNano: encoder.encodeHrTime(log.hrTime),
+    observedTimeUnixNano: encoder.encodeHrTime(log.hrTimeObserved),
+    severityNumber: toSeverityNumber(log.severityNumber),
+    severityText: log.severityText,
+    body: toAnyValue2(log.body, encoder),
+    eventName: log.eventName,
+    attributes: toLogAttributes(log.attributes, encoder),
+    droppedAttributesCount: log.droppedAttributesCount,
+    flags: log.spanContext?.traceFlags,
+    traceId: encoder.encodeOptionalSpanContext(log.spanContext?.traceId),
+    spanId: encoder.encodeOptionalSpanContext(log.spanContext?.spanId)
+  };
+}
+function toSeverityNumber(severityNumber) {
+  return severityNumber;
+}
+function toLogAttributes(attributes, encoder) {
+  return Object.keys(attributes).map((key) => toKeyValue2(key, attributes[key], encoder));
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-transformer/build/esm/common/utils.js
+function hrTimeToNanos2(hrTime4) {
+  const NANOSECONDS = BigInt(1e9);
+  return BigInt(Math.trunc(hrTime4[0])) * NANOSECONDS + BigInt(Math.trunc(hrTime4[1]));
+}
+function encodeAsString2(hrTime4) {
+  const nanos = hrTimeToNanos2(hrTime4);
+  return nanos.toString();
+}
+var encodeTimestamp2 = typeof BigInt !== "undefined" ? encodeAsString2 : hrTimeToNanoseconds3;
+function identity2(value) {
+  return value;
+}
+var JSON_ENCODER = {
+  encodeHrTime: encodeTimestamp2,
+  encodeSpanContext: identity2,
+  encodeOptionalSpanContext: identity2,
+  encodeUint8Array: (bytes) => {
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(bytes).toString("base64");
+    }
+    const chars2 = new Array(bytes.length);
+    for (let i = 0; i < bytes.length; i++) {
+      chars2[i] = String.fromCharCode(bytes[i]);
+    }
+    return btoa(chars2.join(""));
+  }
+};
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-transformer/build/esm/logs/json/logs.js
+var JsonLogsSerializer = {
+  serializeRequest: (arg) => {
+    const request = createExportLogsServiceRequest(arg, JSON_ENCODER);
+    const encoder = new TextEncoder();
+    return encoder.encode(JSON.stringify(request));
+  },
+  deserializeResponse: (arg) => {
+    if (arg.length === 0) {
+      return {};
+    }
+    const decoder = new TextDecoder();
+    return JSON.parse(decoder.decode(arg));
+  }
+};
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/retrying-transport.js
+var MAX_ATTEMPTS2 = 5;
+var INITIAL_BACKOFF2 = 1e3;
+var MAX_BACKOFF2 = 5e3;
+var BACKOFF_MULTIPLIER2 = 1.5;
+var JITTER2 = 0.2;
+function getJitter2() {
+  return Math.random() * (2 * JITTER2) - JITTER2;
+}
+var RetryingTransport2 = class {
+  _transport;
+  constructor(transport) {
+    this._transport = transport;
+  }
+  retry(data, timeoutMillis, inMillis) {
+    return new Promise((resolve2, reject) => {
+      setTimeout(() => {
+        this._transport.send(data, timeoutMillis).then(resolve2, reject);
+      }, inMillis);
+    });
+  }
+  async send(data, timeoutMillis) {
+    let attempts = MAX_ATTEMPTS2;
+    let nextBackoff = INITIAL_BACKOFF2;
+    const deadline = Date.now() + timeoutMillis;
+    let result2 = await this._transport.send(data, timeoutMillis);
+    while (result2.status === "retryable" && attempts > 0) {
+      attempts--;
+      const backoff = Math.max(Math.min(nextBackoff * (1 + getJitter2()), MAX_BACKOFF2), 0);
+      nextBackoff = nextBackoff * BACKOFF_MULTIPLIER2;
+      const retryInMillis = result2.retryInMillis ?? backoff;
+      const remainingTimeoutMillis = deadline - Date.now();
+      if (retryInMillis > remainingTimeoutMillis) {
+        diag2.info(`Export retry time ${Math.round(retryInMillis)}ms exceeds remaining timeout ${Math.round(remainingTimeoutMillis)}ms, not retrying further.`);
+        return result2;
+      }
+      diag2.verbose(`Scheduling export retry in ${Math.round(retryInMillis)}ms`);
+      result2 = await this.retry(data, remainingTimeoutMillis, retryInMillis);
+    }
+    if (result2.status === "success") {
+      diag2.verbose(`Export succeeded after ${MAX_ATTEMPTS2 - attempts} retry attempts.`);
+    } else if (result2.status === "retryable") {
+      diag2.info(`Export failed after maximum retry attempts (${MAX_ATTEMPTS2}).`);
+    } else {
+      diag2.info(`Export failed with non-retryable error: ${result2.error}`);
+    }
+    return result2;
+  }
+  shutdown() {
+    return this._transport.shutdown();
+  }
+};
+function createRetryingTransport2(options) {
+  return new RetryingTransport2(options.transport);
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/is-export-retryable.js
+function isExportHTTPErrorRetryable(statusCode) {
+  return statusCode === 429 || statusCode === 502 || statusCode === 503 || statusCode === 504;
+}
+function parseRetryAfterToMills2(retryAfter) {
+  if (retryAfter == null) {
+    return void 0;
+  }
+  const seconds = Number.parseInt(retryAfter, 10);
+  if (Number.isInteger(seconds)) {
+    return seconds > 0 ? seconds * 1e3 : -1;
+  }
+  const delay = new Date(retryAfter).getTime() - Date.now();
+  if (delay >= 0) {
+    return delay;
+  }
+  return 0;
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/fetch-transport.js
+var MAX_KEEPALIVE_BODY_SIZE = 60 * 1024;
+var MAX_KEEPALIVE_REQUESTS = 9;
+var pendingBodySize = 0;
+var pendingKeepaliveCount = 0;
+var FetchTransport = class {
+  _parameters;
+  constructor(parameters) {
+    this._parameters = parameters;
+  }
+  async send(data, timeoutMillis) {
+    const abortController = new AbortController();
+    const timeout = setTimeout(() => abortController.abort(), timeoutMillis);
+    let fetchApi = globalThis.fetch;
+    if (typeof fetchApi.__original === "function") {
+      fetchApi = fetchApi.__original;
+    }
+    const requestSize = data.byteLength;
+    const wouldExceedSize = pendingBodySize + requestSize > MAX_KEEPALIVE_BODY_SIZE;
+    const wouldExceedCount = pendingKeepaliveCount >= MAX_KEEPALIVE_REQUESTS;
+    const useKeepalive = !wouldExceedSize && !wouldExceedCount;
+    if (useKeepalive) {
+      pendingBodySize += requestSize;
+      pendingKeepaliveCount++;
+    } else {
+      const reason = wouldExceedSize ? "size limit" : "count limit";
+      diag2.debug(`keepalive disabled: ${(requestSize / 1024).toFixed(1)}KB payload, ${pendingKeepaliveCount} pending (${reason})`);
+    }
+    try {
+      const url = new URL(this._parameters.url);
+      const response = await fetchApi(url.href, {
+        method: "POST",
+        headers: await this._parameters.headers(),
+        body: data,
+        signal: abortController.signal,
+        keepalive: useKeepalive,
+        mode: globalThis.location ? globalThis.location.origin === url.origin ? "same-origin" : "cors" : "no-cors"
+      });
+      if (response.status >= 200 && response.status <= 299) {
+        diag2.debug(`export response success (status: ${response.status})`);
+        return { status: "success" };
+      } else if (isExportHTTPErrorRetryable(response.status)) {
+        diag2.warn(`export response retryable (status: ${response.status})`);
+        const retryAfter = response.headers.get("Retry-After");
+        const retryInMillis = parseRetryAfterToMills2(retryAfter);
+        return { status: "retryable", retryInMillis };
+      }
+      diag2.error(`export response failure (status: ${response.status})`);
+      return {
+        status: "failure",
+        error: new Error(`Fetch request failed with non-retryable status ${response.status}`)
+      };
+    } catch (error) {
+      if (isFetchNetworkErrorRetryable(error)) {
+        diag2.warn(`export request retryable (network error: ${error})`);
+        return {
+          status: "retryable",
+          error: new Error("Fetch request encountered a network error", {
+            cause: error
+          })
+        };
+      }
+      diag2.error(`export request failure (error: ${error})`);
+      return {
+        status: "failure",
+        error: new Error("Fetch request errored", { cause: error })
+      };
+    } finally {
+      clearTimeout(timeout);
+      if (useKeepalive) {
+        pendingBodySize -= requestSize;
+        pendingKeepaliveCount--;
+      }
+    }
+  }
+  shutdown() {
+  }
+};
+function createFetchTransport(parameters) {
+  return new FetchTransport(parameters);
+}
+function isFetchNetworkErrorRetryable(error) {
+  return error instanceof TypeError && !error.cause;
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-browser-http-export-delegate.js
+function createOtlpFetchExportDelegate(options, serializer) {
+  return createOtlpNetworkExportDelegate2(options, serializer, createRetryingTransport2({
+    transport: createFetchTransport(options)
+  }));
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/util.js
+function validateAndNormalizeHeaders2(partialHeaders) {
+  const headers = {};
+  Object.entries(partialHeaders ?? {}).forEach(([key, value]) => {
+    if (typeof value !== "undefined") {
+      headers[key] = String(value);
+    } else {
+      diag2.warn(`Header "${key}" has invalid value (${value}) and will be ignored`);
+    }
+  });
+  return headers;
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-configuration.js
+function mergeHeaders2(userProvidedHeaders, fallbackHeaders, defaultHeaders) {
+  return async () => {
+    const requiredHeaders = {
+      ...await defaultHeaders()
+    };
+    const headers = {};
+    if (fallbackHeaders != null) {
+      Object.assign(headers, await fallbackHeaders());
+    }
+    if (userProvidedHeaders != null) {
+      Object.assign(headers, validateAndNormalizeHeaders2(await userProvidedHeaders()));
+    }
+    return Object.assign(headers, requiredHeaders);
+  };
+}
+function validateUserProvidedUrl2(url) {
+  if (url == null) {
+    return void 0;
+  }
+  try {
+    const base = globalThis.location?.href;
+    return new URL(url, base).href;
+  } catch {
+    throw new Error(`Configuration: Could not parse user-provided export URL: '${url}'`);
+  }
+}
+function mergeOtlpHttpConfigurationWithDefaults2(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
+  return {
+    ...mergeOtlpSharedConfigurationWithDefaults2(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration),
+    headers: mergeHeaders2(userProvidedConfiguration.headers, fallbackConfiguration.headers, defaultConfiguration.headers),
+    url: validateUserProvidedUrl2(userProvidedConfiguration.url) ?? fallbackConfiguration.url ?? defaultConfiguration.url
+  };
+}
+function getHttpConfigurationDefaults2(requiredHeaders, signalResourcePath) {
+  return {
+    ...getSharedConfigurationDefaults2(),
+    headers: async () => requiredHeaders,
+    url: "http://localhost:4318/" + signalResourcePath
+  };
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-http-options.js
+function convertLegacyHeaders(config) {
+  if (typeof config.headers === "function") {
+    return config.headers;
+  }
+  return wrapStaticHeadersInFunction2(config.headers);
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-browser-http-options.js
+function convertLegacyBrowserHttpOptions2(config, signalResourcePath, requiredHeaders) {
+  return mergeOtlpHttpConfigurationWithDefaults2(
+    {
+      url: config.url,
+      timeoutMillis: config.timeoutMillis,
+      headers: convertLegacyHeaders(config),
+      concurrencyLimit: config.concurrencyLimit
+    },
+    {},
+    // no fallback for browser case
+    getHttpConfigurationDefaults2(requiredHeaders, signalResourcePath)
+  );
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/create-legacy-browser-delegate.js
+function createLegacyOtlpBrowserExportDelegate2(config, serializer, signalResourcePath, requiredHeaders) {
+  const options = convertLegacyBrowserHttpOptions2(config, signalResourcePath, requiredHeaders);
+  return createOtlpFetchExportDelegate(options, serializer);
+}
+
+// node_modules/@opentelemetry/exporter-logs-otlp-http/build/esm/platform/browser/OTLPLogExporter.js
+var OTLPLogExporter = class extends OTLPExporterBase2 {
+  constructor(config = {}) {
+    super(createLegacyOtlpBrowserExportDelegate2(config, JsonLogsSerializer, "v1/logs", { "Content-Type": "application/json" }));
+  }
+};
+
+// node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/api-logs/build/esm/NoopLogger.js
+var NoopLogger3 = (
+  /** @class */
+  (function() {
+    function NoopLogger5() {
+    }
+    NoopLogger5.prototype.emit = function(_logRecord) {
+    };
+    return NoopLogger5;
+  })()
+);
+var NOOP_LOGGER3 = new NoopLogger3();
+
+// node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/api-logs/build/esm/NoopLoggerProvider.js
+var NoopLoggerProvider3 = (
+  /** @class */
+  (function() {
+    function NoopLoggerProvider5() {
+    }
+    NoopLoggerProvider5.prototype.getLogger = function(_name, _version, _options) {
+      return new NoopLogger3();
+    };
+    return NoopLoggerProvider5;
+  })()
+);
+var NOOP_LOGGER_PROVIDER3 = new NoopLoggerProvider3();
+
+// node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/api-logs/build/esm/ProxyLogger.js
+var ProxyLogger3 = (
+  /** @class */
+  (function() {
+    function ProxyLogger5(_provider, name, version, options) {
+      this._provider = _provider;
+      this.name = name;
+      this.version = version;
+      this.options = options;
+    }
+    ProxyLogger5.prototype.emit = function(logRecord) {
+      this._getLogger().emit(logRecord);
+    };
+    ProxyLogger5.prototype._getLogger = function() {
+      if (this._delegate) {
+        return this._delegate;
+      }
+      var logger = this._provider.getDelegateLogger(this.name, this.version, this.options);
+      if (!logger) {
+        return NOOP_LOGGER3;
+      }
+      this._delegate = logger;
+      return this._delegate;
+    };
+    return ProxyLogger5;
+  })()
+);
+
+// node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/api-logs/build/esm/ProxyLoggerProvider.js
+var ProxyLoggerProvider3 = (
+  /** @class */
   (function() {
-    function ProxyLoggerProvider4() {
+    function ProxyLoggerProvider5() {
     }
-    ProxyLoggerProvider4.prototype.getLogger = function(name, version, options) {
+    ProxyLoggerProvider5.prototype.getLogger = function(name, version, options) {
       var _a4;
-      return (_a4 = this.getDelegateLogger(name, version, options)) !== null && _a4 !== void 0 ? _a4 : new ProxyLogger(this, name, version, options);
+      return (_a4 = this.getDelegateLogger(name, version, options)) !== null && _a4 !== void 0 ? _a4 : new ProxyLogger3(this, name, version, options);
     };
-    ProxyLoggerProvider4.prototype.getDelegate = function() {
+    ProxyLoggerProvider5.prototype.getDelegate = function() {
       var _a4;
-      return (_a4 = this._delegate) !== null && _a4 !== void 0 ? _a4 : NOOP_LOGGER_PROVIDER;
+      return (_a4 = this._delegate) !== null && _a4 !== void 0 ? _a4 : NOOP_LOGGER_PROVIDER3;
     };
-    ProxyLoggerProvider4.prototype.setDelegate = function(delegate) {
+    ProxyLoggerProvider5.prototype.setDelegate = function(delegate) {
       this._delegate = delegate;
     };
-    ProxyLoggerProvider4.prototype.getDelegateLogger = function(name, version, options) {
+    ProxyLoggerProvider5.prototype.getDelegateLogger = function(name, version, options) {
       var _a4;
       return (_a4 = this._delegate) === null || _a4 === void 0 ? void 0 : _a4.getLogger(name, version, options);
     };
-    return ProxyLoggerProvider4;
+    return ProxyLoggerProvider5;
   })()
 );
 
 // node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/api-logs/build/esm/platform/browser/globalThis.js
-var _globalThis2 = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+var _globalThis4 = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
 
 // node_modules/@opentelemetry/instrumentation-fetch/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 _global2 = _globalThis2;
-function makeGetter(requiredVersion, instance, fallback) {
+var GLOBAL_LOGS_API_KEY3 = /* @__PURE__ */ Symbol.for("io.opentelemetry.js.api.logs");
+var _global4 = _globalThis4;
+function makeGetter3(requiredVersion, instance, fallback) {
   return function(version) {
     return version === requiredVersion ? instance : fallback;
   };
 }
-var API_BACKWARDS_COMPATIBILITY_VERSION = 1;
+var API_BACKWARDS_COMPATIBILITY_VERSION3 = 1;
 
 // node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/api-logs/build/esm/api/logs.js
-var LogsAPI = (
+var LogsAPI3 = (
   /** @class */
   (function() {
-    function LogsAPI4() {
-      this._proxyLoggerProvider = new ProxyLoggerProvider();
+    function LogsAPI5() {
+      this._proxyLoggerProvider = new ProxyLoggerProvider3();
     }
-    LogsAPI4.getInstance = function() {
+    LogsAPI5.getInstance = function() {
       if (!this._instance) {
-        this._instance = new LogsAPI4();
+        this._instance = new LogsAPI5();
       }
       return this._instance;
     };
-    LogsAPI4.prototype.setGlobalLoggerProvider = function(provider) {
-      if (_global2[GLOBAL_LOGS_API_KEY]) {
+    LogsAPI5.prototype.setGlobalLoggerProvider = function(provider) {
+      if (_global4[GLOBAL_LOGS_API_KEY3]) {
         return this.getLoggerProvider();
       }
-      _global2[GLOBAL_LOGS_API_KEY] = makeGetter(API_BACKWARDS_COMPATIBILITY_VERSION, provider, NOOP_LOGGER_PROVIDER);
+      _global4[GLOBAL_LOGS_API_KEY3] = makeGetter3(API_BACKWARDS_COMPATIBILITY_VERSION3, provider, NOOP_LOGGER_PROVIDER3);
       this._proxyLoggerProvider.setDelegate(provider);
       return provider;
     };
-    LogsAPI4.prototype.getLoggerProvider = function() {
+    LogsAPI5.prototype.getLoggerProvider = function() {
       var _a4, _b;
-      return (_b = (_a4 = _global2[GLOBAL_LOGS_API_KEY]) === null || _a4 === void 0 ? void 0 : _a4.call(_global2, API_BACKWARDS_COMPATIBILITY_VERSION)) !== null && _b !== void 0 ? _b : this._proxyLoggerProvider;
+      return (_b = (_a4 = _global4[GLOBAL_LOGS_API_KEY3]) === null || _a4 === void 0 ? void 0 : _a4.call(_global4, API_BACKWARDS_COMPATIBILITY_VERSION3)) !== null && _b !== void 0 ? _b : this._proxyLoggerProvider;
     };
-    LogsAPI4.prototype.getLogger = function(name, version, options) {
+    LogsAPI5.prototype.getLogger = function(name, version, options) {
       return this.getLoggerProvider().getLogger(name, version, options);
     };
-    LogsAPI4.prototype.disable = function() {
-      delete _global2[GLOBAL_LOGS_API_KEY];
-      this._proxyLoggerProvider = new ProxyLoggerProvider();
+    LogsAPI5.prototype.disable = function() {
+      delete _global4[GLOBAL_LOGS_API_KEY3];
+      this._proxyLoggerProvider = new ProxyLoggerProvider3();
     };
-    return LogsAPI4;
+    return LogsAPI5;
   })()
 );
 
 // node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/api-logs/build/esm/index.js
-var logs = LogsAPI.getInstance();
+var logs3 = LogsAPI3.getInstance();
 
 // node_modules/@opentelemetry/instrumentation-fetch/node_modules/@opentelemetry/instrumentation/build/esm/instrumentation.js
 var shimmer = __toESM(require_shimmer());
@@ -22804,7 +24718,7 @@ var InstrumentationAbstract = (
       });
       this._tracer = trace.getTracer(instrumentationName, instrumentationVersion);
       this._meter = metrics.getMeter(instrumentationName, instrumentationVersion);
-      this._logger = logs.getLogger(instrumentationName, instrumentationVersion);
+      this._logger = logs3.getLogger(instrumentationName, instrumentationVersion);
       this._updateMetricInstruments();
     }
     Object.defineProperty(InstrumentationAbstract4.prototype, "meter", {
@@ -23202,7 +25116,7 @@ function getFormDataSize(formData) {
 }
 
 // node_modules/@opentelemetry/instrumentation-fetch/build/esm/version.js
-var VERSION4 = "0.57.2";
+var VERSION5 = "0.57.2";
 
 // node_modules/@opentelemetry/instrumentation-fetch/build/esm/fetch.js
 var __extends17 = /* @__PURE__ */ (function() {
@@ -23261,9 +25175,9 @@ var FetchInstrumentation = (
       if (config === void 0) {
         config = {};
       }
-      var _this = _super.call(this, "@opentelemetry/instrumentation-fetch", VERSION4, config) || this;
+      var _this = _super.call(this, "@opentelemetry/instrumentation-fetch", VERSION5, config) || this;
       _this.component = "fetch";
-      _this.version = VERSION4;
+      _this.version = VERSION5;
       _this.moduleName = _this.component;
       _this._usedResources = /* @__PURE__ */ new WeakSet();
       _this._tasksCount = 0;
@@ -23511,16 +25425,16 @@ var FetchInstrumentation = (
         return;
       }
       if (isWrapped(fetch)) {
-        this._unwrap(_globalThis, "fetch");
+        this._unwrap(_globalThis2, "fetch");
         this._diag.debug("removing previous patch for constructor");
       }
-      this._wrap(_globalThis, "fetch", this._patchConstructor());
+      this._wrap(_globalThis2, "fetch", this._patchConstructor());
     };
     FetchInstrumentation2.prototype.disable = function() {
       if (isNode) {
         return;
       }
-      this._unwrap(_globalThis, "fetch");
+      this._unwrap(_globalThis2, "fetch");
       this._usedResources = /* @__PURE__ */ new WeakSet();
     };
     return FetchInstrumentation2;
@@ -23528,136 +25442,136 @@ var FetchInstrumentation = (
 );
 
 // node_modules/@opentelemetry/instrumentation-xml-http-request/node_modules/@opentelemetry/api-logs/build/esm/NoopLogger.js
-var NoopLogger2 = (
+var NoopLogger4 = (
   /** @class */
   (function() {
-    function NoopLogger4() {
+    function NoopLogger5() {
     }
-    NoopLogger4.prototype.emit = function(_logRecord) {
+    NoopLogger5.prototype.emit = function(_logRecord) {
     };
-    return NoopLogger4;
+    return NoopLogger5;
   })()
 );
-var NOOP_LOGGER2 = new NoopLogger2();
+var NOOP_LOGGER4 = new NoopLogger4();
 
 // node_modules/@opentelemetry/instrumentation-xml-http-request/node_modules/@opentelemetry/api-logs/build/esm/NoopLoggerProvider.js
-var NoopLoggerProvider2 = (
+var NoopLoggerProvider4 = (
   /** @class */
   (function() {
-    function NoopLoggerProvider4() {
+    function NoopLoggerProvider5() {
     }
-    NoopLoggerProvider4.prototype.getLogger = function(_name, _version, _options) {
-      return new NoopLogger2();
+    NoopLoggerProvider5.prototype.getLogger = function(_name, _version, _options) {
+      return new NoopLogger4();
     };
-    return NoopLoggerProvider4;
+    return NoopLoggerProvider5;
   })()
 );
-var NOOP_LOGGER_PROVIDER2 = new NoopLoggerProvider2();
+var NOOP_LOGGER_PROVIDER4 = new NoopLoggerProvider4();
 
 // node_modules/@opentelemetry/instrumentation-xml-http-request/node_modules/@opentelemetry/api-logs/build/esm/ProxyLogger.js
-var ProxyLogger2 = (
+var ProxyLogger4 = (
   /** @class */
   (function() {
-    function ProxyLogger4(_provider, name, version, options) {
+    function ProxyLogger5(_provider, name, version, options) {
       this._provider = _provider;
       this.name = name;
       this.version = version;
       this.options = options;
     }
-    ProxyLogger4.prototype.emit = function(logRecord) {
+    ProxyLogger5.prototype.emit = function(logRecord) {
       this._getLogger().emit(logRecord);
     };
-    ProxyLogger4.prototype._getLogger = function() {
+    ProxyLogger5.prototype._getLogger = function() {
       if (this._delegate) {
         return this._delegate;
       }
       var logger = this._provider.getDelegateLogger(this.name, this.version, this.options);
       if (!logger) {
-        return NOOP_LOGGER2;
+        return NOOP_LOGGER4;
       }
       this._delegate = logger;
       return this._delegate;
     };
-    return ProxyLogger4;
+    return ProxyLogger5;
   })()
 );
 
 // node_modules/@opentelemetry/instrumentation-xml-http-request/node_modules/@opentelemetry/api-logs/build/esm/ProxyLoggerProvider.js
-var ProxyLoggerProvider2 = (
+var ProxyLoggerProvider4 = (
   /** @class */
   (function() {
-    function ProxyLoggerProvider4() {
+    function ProxyLoggerProvider5() {
     }
-    ProxyLoggerProvider4.prototype.getLogger = function(name, version, options) {
+    ProxyLoggerProvider5.prototype.getLogger = function(name, version, options) {
       var _a4;
-      return (_a4 = this.getDelegateLogger(name, version, options)) !== null && _a4 !== void 0 ? _a4 : new ProxyLogger2(this, name, version, options);
+      return (_a4 = this.getDelegateLogger(name, version, options)) !== null && _a4 !== void 0 ? _a4 : new ProxyLogger4(this, name, version, options);
     };
-    ProxyLoggerProvider4.prototype.getDelegate = function() {
+    ProxyLoggerProvider5.prototype.getDelegate = function() {
       var _a4;
-      return (_a4 = this._delegate) !== null && _a4 !== void 0 ? _a4 : NOOP_LOGGER_PROVIDER2;
+      return (_a4 = this._delegate) !== null && _a4 !== void 0 ? _a4 : NOOP_LOGGER_PROVIDER4;
     };
-    ProxyLoggerProvider4.prototype.setDelegate = function(delegate) {
+    ProxyLoggerProvider5.prototype.setDelegate = function(delegate) {
       this._delegate = delegate;
     };
-    ProxyLoggerProvider4.prototype.getDelegateLogger = function(name, version, options) {
+    ProxyLoggerProvider5.prototype.getDelegateLogger = function(name, version, options) {
       var _a4;
       return (_a4 = this._delegate) === null || _a4 === void 0 ? void 0 : _a4.getLogger(name, version, options);
     };
-    return ProxyLoggerProvider4;
+    return ProxyLoggerProvider5;
   })()
 );
 
 // node_modules/@opentelemetry/instrumentation-xml-http-request/node_modules/@opentelemetry/api-logs/build/esm/platform/browser/globalThis.js
-var _globalThis3 = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+var _globalThis5 = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
 
 // node_modules/@opentelemetry/instrumentation-xml-http-request/node_modules/@opentelemetry/api-logs/build/esm/internal/global-utils.js
-var GLOBAL_LOGS_API_KEY2 = /* @__PURE__ */ Symbol.for("io.opentelemetry.js.api.logs");
-var _global3 = _globalThis3;
-function makeGetter2(requiredVersion, instance, fallback) {
+var GLOBAL_LOGS_API_KEY4 = /* @__PURE__ */ Symbol.for("io.opentelemetry.js.api.logs");
+var _global5 = _globalThis5;
+function makeGetter4(requiredVersion, instance, fallback) {
   return function(version) {
     return version === requiredVersion ? instance : fallback;
   };
 }
-var API_BACKWARDS_COMPATIBILITY_VERSION2 = 1;
+var API_BACKWARDS_COMPATIBILITY_VERSION4 = 1;
 
 // node_modules/@opentelemetry/instrumentation-xml-http-request/node_modules/@opentelemetry/api-logs/build/esm/api/logs.js
-var LogsAPI2 = (
+var LogsAPI4 = (
   /** @class */
   (function() {
-    function LogsAPI4() {
-      this._proxyLoggerProvider = new ProxyLoggerProvider2();
+    function LogsAPI5() {
+      this._proxyLoggerProvider = new ProxyLoggerProvider4();
     }
-    LogsAPI4.getInstance = function() {
+    LogsAPI5.getInstance = function() {
       if (!this._instance) {
-        this._instance = new LogsAPI4();
+        this._instance = new LogsAPI5();
       }
       return this._instance;
     };
-    LogsAPI4.prototype.setGlobalLoggerProvider = function(provider) {
-      if (_global3[GLOBAL_LOGS_API_KEY2]) {
+    LogsAPI5.prototype.setGlobalLoggerProvider = function(provider) {
+      if (_global5[GLOBAL_LOGS_API_KEY4]) {
         return this.getLoggerProvider();
       }
-      _global3[GLOBAL_LOGS_API_KEY2] = makeGetter2(API_BACKWARDS_COMPATIBILITY_VERSION2, provider, NOOP_LOGGER_PROVIDER2);
+      _global5[GLOBAL_LOGS_API_KEY4] = makeGetter4(API_BACKWARDS_COMPATIBILITY_VERSION4, provider, NOOP_LOGGER_PROVIDER4);
       this._proxyLoggerProvider.setDelegate(provider);
       return provider;
     };
-    LogsAPI4.prototype.getLoggerProvider = function() {
+    LogsAPI5.prototype.getLoggerProvider = function() {
       var _a4, _b;
-      return (_b = (_a4 = _global3[GLOBAL_LOGS_API_KEY2]) === null || _a4 === void 0 ? void 0 : _a4.call(_global3, API_BACKWARDS_COMPATIBILITY_VERSION2)) !== null && _b !== void 0 ? _b : this._proxyLoggerProvider;
+      return (_b = (_a4 = _global5[GLOBAL_LOGS_API_KEY4]) === null || _a4 === void 0 ? void 0 : _a4.call(_global5, API_BACKWARDS_COMPATIBILITY_VERSION4)) !== null && _b !== void 0 ? _b : this._proxyLoggerProvider;
     };
-    LogsAPI4.prototype.getLogger = function(name, version, options) {
+    LogsAPI5.prototype.getLogger = function(name, version, options) {
       return this.getLoggerProvider().getLogger(name, version, options);
     };
-    LogsAPI4.prototype.disable = function() {
-      delete _global3[GLOBAL_LOGS_API_KEY2];
-      this._proxyLoggerProvider = new ProxyLoggerProvider2();
+    LogsAPI5.prototype.disable = function() {
+      delete _global5[GLOBAL_LOGS_API_KEY4];
+      this._proxyLoggerProvider = new ProxyLoggerProvider4();
     };
-    return LogsAPI4;
+    return LogsAPI5;
   })()
 );
 
 // node_modules/@opentelemetry/instrumentation-xml-http-request/node_modules/@opentelemetry/api-logs/build/esm/index.js
-var logs2 = LogsAPI2.getInstance();
+var logs4 = LogsAPI4.getInstance();
 
 // node_modules/@opentelemetry/instrumentation-xml-http-request/node_modules/@opentelemetry/instrumentation/build/esm/instrumentation.js
 var shimmer2 = __toESM(require_shimmer());
@@ -23689,7 +25603,7 @@ var InstrumentationAbstract2 = (
       });
       this._tracer = trace.getTracer(instrumentationName, instrumentationVersion);
       this._meter = metrics.getMeter(instrumentationName, instrumentationVersion);
-      this._logger = logs2.getLogger(instrumentationName, instrumentationVersion);
+      this._logger = logs4.getLogger(instrumentationName, instrumentationVersion);
       this._updateMetricInstruments();
     }
     Object.defineProperty(InstrumentationAbstract4.prototype, "meter", {
@@ -23923,7 +25837,7 @@ function getFormDataSize2(formData) {
 }
 
 // node_modules/@opentelemetry/instrumentation-xml-http-request/build/esm/version.js
-var VERSION5 = "0.57.2";
+var VERSION6 = "0.57.2";
 
 // node_modules/@opentelemetry/instrumentation-xml-http-request/build/esm/enums/AttributeNames.js
 var AttributeNames2;
@@ -23960,9 +25874,9 @@ var XMLHttpRequestInstrumentation = (
       if (config === void 0) {
         config = {};
       }
-      var _this = _super.call(this, "@opentelemetry/instrumentation-xml-http-request", VERSION5, config) || this;
+      var _this = _super.call(this, "@opentelemetry/instrumentation-xml-http-request", VERSION6, config) || this;
       _this.component = "xml-http-request";
-      _this.version = VERSION5;
+      _this.version = VERSION6;
       _this.moduleName = _this.component;
       _this._tasksCount = 0;
       _this._xhrMem = /* @__PURE__ */ new WeakMap();
@@ -24251,138 +26165,6 @@ var XMLHttpRequestInstrumentation = (
   })(InstrumentationBase2)
 );
 
-// node_modules/@opentelemetry/api-logs/build/esm/NoopLogger.js
-var NoopLogger3 = (
-  /** @class */
-  (function() {
-    function NoopLogger4() {
-    }
-    NoopLogger4.prototype.emit = function(_logRecord) {
-    };
-    return NoopLogger4;
-  })()
-);
-var NOOP_LOGGER3 = new NoopLogger3();
-
-// node_modules/@opentelemetry/api-logs/build/esm/NoopLoggerProvider.js
-var NoopLoggerProvider3 = (
-  /** @class */
-  (function() {
-    function NoopLoggerProvider4() {
-    }
-    NoopLoggerProvider4.prototype.getLogger = function(_name, _version, _options) {
-      return new NoopLogger3();
-    };
-    return NoopLoggerProvider4;
-  })()
-);
-var NOOP_LOGGER_PROVIDER3 = new NoopLoggerProvider3();
-
-// node_modules/@opentelemetry/api-logs/build/esm/ProxyLogger.js
-var ProxyLogger3 = (
-  /** @class */
-  (function() {
-    function ProxyLogger4(_provider, name, version, options) {
-      this._provider = _provider;
-      this.name = name;
-      this.version = version;
-      this.options = options;
-    }
-    ProxyLogger4.prototype.emit = function(logRecord) {
-      this._getLogger().emit(logRecord);
-    };
-    ProxyLogger4.prototype._getLogger = function() {
-      if (this._delegate) {
-        return this._delegate;
-      }
-      var logger = this._provider.getDelegateLogger(this.name, this.version, this.options);
-      if (!logger) {
-        return NOOP_LOGGER3;
-      }
-      this._delegate = logger;
-      return this._delegate;
-    };
-    return ProxyLogger4;
-  })()
-);
-
-// node_modules/@opentelemetry/api-logs/build/esm/ProxyLoggerProvider.js
-var ProxyLoggerProvider3 = (
-  /** @class */
-  (function() {
-    function ProxyLoggerProvider4() {
-    }
-    ProxyLoggerProvider4.prototype.getLogger = function(name, version, options) {
-      var _a4;
-      return (_a4 = this.getDelegateLogger(name, version, options)) !== null && _a4 !== void 0 ? _a4 : new ProxyLogger3(this, name, version, options);
-    };
-    ProxyLoggerProvider4.prototype.getDelegate = function() {
-      var _a4;
-      return (_a4 = this._delegate) !== null && _a4 !== void 0 ? _a4 : NOOP_LOGGER_PROVIDER3;
-    };
-    ProxyLoggerProvider4.prototype.setDelegate = function(delegate) {
-      this._delegate = delegate;
-    };
-    ProxyLoggerProvider4.prototype.getDelegateLogger = function(name, version, options) {
-      var _a4;
-      return (_a4 = this._delegate) === null || _a4 === void 0 ? void 0 : _a4.getLogger(name, version, options);
-    };
-    return ProxyLoggerProvider4;
-  })()
-);
-
-// node_modules/@opentelemetry/api-logs/build/esm/platform/browser/globalThis.js
-var _globalThis4 = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
-
-// node_modules/@opentelemetry/api-logs/build/esm/internal/global-utils.js
-var GLOBAL_LOGS_API_KEY3 = /* @__PURE__ */ Symbol.for("io.opentelemetry.js.api.logs");
-var _global4 = _globalThis4;
-function makeGetter3(requiredVersion, instance, fallback) {
-  return function(version) {
-    return version === requiredVersion ? instance : fallback;
-  };
-}
-var API_BACKWARDS_COMPATIBILITY_VERSION3 = 1;
-
-// node_modules/@opentelemetry/api-logs/build/esm/api/logs.js
-var LogsAPI3 = (
-  /** @class */
-  (function() {
-    function LogsAPI4() {
-      this._proxyLoggerProvider = new ProxyLoggerProvider3();
-    }
-    LogsAPI4.getInstance = function() {
-      if (!this._instance) {
-        this._instance = new LogsAPI4();
-      }
-      return this._instance;
-    };
-    LogsAPI4.prototype.setGlobalLoggerProvider = function(provider) {
-      if (_global4[GLOBAL_LOGS_API_KEY3]) {
-        return this.getLoggerProvider();
-      }
-      _global4[GLOBAL_LOGS_API_KEY3] = makeGetter3(API_BACKWARDS_COMPATIBILITY_VERSION3, provider, NOOP_LOGGER_PROVIDER3);
-      this._proxyLoggerProvider.setDelegate(provider);
-      return provider;
-    };
-    LogsAPI4.prototype.getLoggerProvider = function() {
-      var _a4, _b;
-      return (_b = (_a4 = _global4[GLOBAL_LOGS_API_KEY3]) === null || _a4 === void 0 ? void 0 : _a4.call(_global4, API_BACKWARDS_COMPATIBILITY_VERSION3)) !== null && _b !== void 0 ? _b : this._proxyLoggerProvider;
-    };
-    LogsAPI4.prototype.getLogger = function(name, version, options) {
-      return this.getLoggerProvider().getLogger(name, version, options);
-    };
-    LogsAPI4.prototype.disable = function() {
-      delete _global4[GLOBAL_LOGS_API_KEY3];
-      this._proxyLoggerProvider = new ProxyLoggerProvider3();
-    };
-    return LogsAPI4;
-  })()
-);
-
-// node_modules/@opentelemetry/api-logs/build/esm/index.js
-var logs3 = LogsAPI3.getInstance();
-
 // node_modules/@opentelemetry/instrumentation/build/esm/autoLoaderUtils.js
 function enableInstrumentations(instrumentations, tracerProvider, meterProvider, loggerProvider) {
   for (var i = 0, j = instrumentations.length; i < j; i++) {
@@ -24412,7 +26194,7 @@ function registerInstrumentations(options) {
   var _a4, _b;
   var tracerProvider = options.tracerProvider || trace.getTracerProvider();
   var meterProvider = options.meterProvider || metrics.getMeterProvider();
-  var loggerProvider = options.loggerProvider || logs3.getLoggerProvider();
+  var loggerProvider = options.loggerProvider || logs.getLoggerProvider();
   var instrumentations = (_b = (_a4 = options.instrumentations) === null || _a4 === void 0 ? void 0 : _a4.flat()) !== null && _b !== void 0 ? _b : [];
   enableInstrumentations(instrumentations, tracerProvider, meterProvider, loggerProvider);
   return function() {
@@ -24450,7 +26232,7 @@ var InstrumentationAbstract3 = (
       });
       this._tracer = trace.getTracer(instrumentationName, instrumentationVersion);
       this._meter = metrics.getMeter(instrumentationName, instrumentationVersion);
-      this._logger = logs3.getLogger(instrumentationName, instrumentationVersion);
+      this._logger = logs.getLogger(instrumentationName, instrumentationVersion);
       this._updateMetricInstruments();
     }
     Object.defineProperty(InstrumentationAbstract4.prototype, "meter", {
@@ -25953,7 +27735,7 @@ function scheduleMacroTaskWithCurrentZone(source, callback, data, customSchedule
 var zoneSymbol = __symbol__;
 var isWindowExists = typeof window !== "undefined";
 var internalWindow = isWindowExists ? window : void 0;
-var _global5 = isWindowExists && internalWindow || globalThis;
+var _global6 = isWindowExists && internalWindow || globalThis;
 var REMOVE_ATTRIBUTE = "removeAttribute";
 function bindArguments(args, source) {
   for (let i = args.length - 1; i >= 0; i--) {
@@ -25993,13 +27775,13 @@ function isPropertyWritable(propertyDesc) {
   return !(typeof propertyDesc.get === "function" && typeof propertyDesc.set === "undefined");
 }
 var isWebWorker = typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
-var isNode2 = !("nw" in _global5) && typeof _global5.process !== "undefined" && _global5.process.toString() === "[object process]";
+var isNode2 = !("nw" in _global6) && typeof _global6.process !== "undefined" && _global6.process.toString() === "[object process]";
 var isBrowser = !isNode2 && !isWebWorker && !!(isWindowExists && internalWindow["HTMLElement"]);
-var isMix = typeof _global5.process !== "undefined" && _global5.process.toString() === "[object process]" && !isWebWorker && !!(isWindowExists && internalWindow["HTMLElement"]);
+var isMix = typeof _global6.process !== "undefined" && _global6.process.toString() === "[object process]" && !isWebWorker && !!(isWindowExists && internalWindow["HTMLElement"]);
 var zoneSymbolEventNames$1 = {};
 var enableBeforeunloadSymbol = zoneSymbol("enable_beforeunload");
 var wrapFn = function(event) {
-  event = event || _global5.event;
+  event = event || _global6.event;
   if (!event) {
     return;
   }
@@ -26007,7 +27789,7 @@ var wrapFn = function(event) {
   if (!eventNameSymbol) {
     eventNameSymbol = zoneSymbolEventNames$1[event.type] = zoneSymbol("ON_PROPERTY" + event.type);
   }
-  const target = this || event.target || _global5;
+  const target = this || event.target || _global6;
   const listener = target[eventNameSymbol];
   let result2;
   if (isBrowser && target === internalWindow && event.type === "error") {
@@ -26029,7 +27811,7 @@ var wrapFn = function(event) {
       // that behavior behind a global configuration flag. Consumers can enable this
       // flag explicitly if they want the `beforeunload` event to be handled as defined
       // in the specification.
-      _global5[enableBeforeunloadSymbol] && // The IDL event definition is `attribute DOMString returnValue`, so we check whether
+      _global6[enableBeforeunloadSymbol] && // The IDL event definition is `attribute DOMString returnValue`, so we check whether
       // `typeof result` is a string.
       typeof result2 === "string"
     ) {
@@ -26066,8 +27848,8 @@ function patchProperty(obj, prop, prototype) {
   }
   desc.set = function(newValue) {
     let target = this;
-    if (!target && obj === _global5) {
-      target = _global5;
+    if (!target && obj === _global6) {
+      target = _global6;
     }
     if (!target) {
       return;
@@ -26084,8 +27866,8 @@ function patchProperty(obj, prop, prototype) {
   };
   desc.get = function() {
     let target = this;
-    if (!target && obj === _global5) {
-      target = _global5;
+    if (!target && obj === _global6) {
+      target = _global6;
     }
     if (!target) {
       return null;
@@ -26127,11 +27909,11 @@ function patchOnProperties(obj, properties, prototype) {
 }
 var originalInstanceKey = zoneSymbol("originalInstance");
 function patchClass(className) {
-  const OriginalClass = _global5[className];
+  const OriginalClass = _global6[className];
   if (!OriginalClass)
     return;
-  _global5[zoneSymbol(className)] = OriginalClass;
-  _global5[className] = function() {
+  _global6[zoneSymbol(className)] = OriginalClass;
+  _global6[className] = function() {
     const a = bindArguments(arguments, className);
     switch (a.length) {
       case 0:
@@ -26153,7 +27935,7 @@ function patchClass(className) {
         throw new Error("Arg list too long.");
     }
   };
-  attachOriginToPatched(_global5[className], OriginalClass);
+  attachOriginToPatched(_global6[className], OriginalClass);
   const instance = new OriginalClass(function() {
   });
   let prop;
@@ -26162,11 +27944,11 @@ function patchClass(className) {
       continue;
     (function(prop2) {
       if (typeof instance[prop2] === "function") {
-        _global5[className].prototype[prop2] = function() {
+        _global6[className].prototype[prop2] = function() {
           return this[originalInstanceKey][prop2].apply(this[originalInstanceKey], arguments);
         };
       } else {
-        ObjectDefineProperty(_global5[className].prototype, prop2, {
+        ObjectDefineProperty(_global6[className].prototype, prop2, {
           set: function(fn) {
             if (typeof fn === "function") {
               this[originalInstanceKey][prop2] = wrapWithCurrentZone(fn, className + "." + prop2);
@@ -26184,7 +27966,7 @@ function patchClass(className) {
   }
   for (prop in OriginalClass) {
     if (prop !== "prototype" && OriginalClass.hasOwnProperty(prop)) {
-      _global5[className][prop] = OriginalClass[prop];
+      _global6[className][prop] = OriginalClass[prop];
     }
   }
 }
@@ -26295,7 +28077,7 @@ function prepareEventNames(eventName, eventNameToString) {
   zoneSymbolEventNames[eventName][FALSE_STR] = symbol;
   zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture;
 }
-function patchEventTarget(_global6, api, apis, patchOptions) {
+function patchEventTarget(_global7, api, apis, patchOptions) {
   const ADD_EVENT_LISTENER = patchOptions && patchOptions.add || ADD_EVENT_LISTENER_STR;
   const REMOVE_EVENT_LISTENER = patchOptions && patchOptions.rm || REMOVE_EVENT_LISTENER_STR;
   const LISTENERS_EVENT_LISTENER = patchOptions && patchOptions.listeners || "eventListeners";
@@ -26327,11 +28109,11 @@ function patchEventTarget(_global6, api, apis, patchOptions) {
     return error;
   };
   function globalCallback(context2, event, isCapture) {
-    event = event || _global6.event;
+    event = event || _global7.event;
     if (!event) {
       return;
     }
-    const target = context2 || event.target || _global6;
+    const target = context2 || event.target || _global7;
     const tasks = target[zoneSymbolEventNames[event.type][isCapture ? TRUE_STR : FALSE_STR]];
     if (tasks) {
       const errors = [];
@@ -26479,7 +28261,7 @@ function patchEventTarget(_global6, api, apis, patchOptions) {
     };
     const compare = patchOptions2 && patchOptions2.diff ? patchOptions2.diff : compareTaskCallbackVsDelegate;
     const unpatchedEvents = Zone[zoneSymbol("UNPATCHED_EVENTS")];
-    const passiveEvents = _global6[zoneSymbol("PASSIVE_EVENTS")];
+    const passiveEvents = _global7[zoneSymbol("PASSIVE_EVENTS")];
     function copyEventListenerOptions(options) {
       if (typeof options === "object" && options !== null) {
         const newOptions = { ...options };
@@ -26492,7 +28274,7 @@ function patchEventTarget(_global6, api, apis, patchOptions) {
     }
     const makeAddListener = function(nativeListener, addSource, customScheduleFn, customCancelFn, returnTarget2 = false, prepend = false) {
       return function() {
-        const target = this || _global6;
+        const target = this || _global7;
         let eventName = arguments[0];
         if (patchOptions2 && patchOptions2.transferEventName) {
           eventName = patchOptions2.transferEventName(eventName);
@@ -26616,7 +28398,7 @@ function patchEventTarget(_global6, api, apis, patchOptions) {
       proto[PREPEND_EVENT_LISTENER] = makeAddListener(nativePrependEventListener, PREPEND_EVENT_LISTENER_SOURCE, customSchedulePrepend, customCancel, returnTarget, true);
     }
     proto[REMOVE_EVENT_LISTENER] = function() {
-      const target = this || _global6;
+      const target = this || _global7;
       let eventName = arguments[0];
       if (patchOptions2 && patchOptions2.transferEventName) {
         eventName = patchOptions2.transferEventName(eventName);
@@ -26661,7 +28443,7 @@ function patchEventTarget(_global6, api, apis, patchOptions) {
       return nativeRemoveEventListener.apply(this, arguments);
     };
     proto[LISTENERS_EVENT_LISTENER] = function() {
-      const target = this || _global6;
+      const target = this || _global7;
       let eventName = arguments[0];
       if (patchOptions2 && patchOptions2.transferEventName) {
         eventName = patchOptions2.transferEventName(eventName);
@@ -26676,7 +28458,7 @@ function patchEventTarget(_global6, api, apis, patchOptions) {
       return listeners;
     };
     proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER] = function() {
-      const target = this || _global6;
+      const target = this || _global7;
       let eventName = arguments[0];
       if (!eventName) {
         const keys = Object.keys(target);
@@ -26882,9 +28664,9 @@ function patchTimer(window2, setName, cancelName, nameSuffix) {
     }
   });
 }
-function patchCustomElements(_global6, api) {
+function patchCustomElements(_global7, api) {
   const { isBrowser: isBrowser2, isMix: isMix2 } = api.getGlobalObjects();
-  if (!isBrowser2 && !isMix2 || !_global6["customElements"] || !("customElements" in _global6)) {
+  if (!isBrowser2 && !isMix2 || !_global7["customElements"] || !("customElements" in _global7)) {
     return;
   }
   const callbacks = [
@@ -26897,9 +28679,9 @@ function patchCustomElements(_global6, api) {
     "formResetCallback",
     "formStateRestoreCallback"
   ];
-  api.patchCallbacks(api, _global6.customElements, "customElements", "define", callbacks);
+  api.patchCallbacks(api, _global7.customElements, "customElements", "define", callbacks);
 }
-function eventTargetPatch(_global6, api) {
+function eventTargetPatch(_global7, api) {
   if (Zone[api.symbol("patchEventTarget")]) {
     return;
   }
@@ -26914,11 +28696,11 @@ function eventTargetPatch(_global6, api) {
     zoneSymbolEventNames2[eventName][FALSE_STR2] = symbol;
     zoneSymbolEventNames2[eventName][TRUE_STR2] = symbolCapture;
   }
-  const EVENT_TARGET = _global6["EventTarget"];
+  const EVENT_TARGET = _global7["EventTarget"];
   if (!EVENT_TARGET || !EVENT_TARGET.prototype) {
     return;
   }
-  api.patchEventTarget(_global6, api, [EVENT_TARGET && EVENT_TARGET.prototype]);
+  api.patchEventTarget(_global7, api, [EVENT_TARGET && EVENT_TARGET.prototype]);
   return true;
 }
 function patchEvent(global3, api) {
@@ -26945,14 +28727,14 @@ function patchFilteredProperties(target, onProperties, ignoreProperties, prototy
 function getOnEventNames(target) {
   return Object.getOwnPropertyNames(target).filter((name) => name.startsWith("on") && name.length > 2).map((name) => name.substring(2));
 }
-function propertyDescriptorPatch(api, _global6) {
+function propertyDescriptorPatch(api, _global7) {
   if (isNode2 && !isMix) {
     return;
   }
   if (Zone[api.symbol("patchEvents")]) {
     return;
   }
-  const ignoreProperties = _global6["__Zone_ignore_on_properties"];
+  const ignoreProperties = _global7["__Zone_ignore_on_properties"];
   let patchTargets = [];
   if (isBrowser) {
     const internalWindow2 = window;
@@ -26984,7 +28766,7 @@ function propertyDescriptorPatch(api, _global6) {
     "WebSocket"
   ]);
   for (let i = 0; i < patchTargets.length; i++) {
-    const target = _global6[patchTargets[i]];
+    const target = _global7[patchTargets[i]];
     target && target.prototype && patchFilteredProperties(target.prototype, getOnEventNames(target.prototype), ignoreProperties);
   }
 }
@@ -27766,6 +29548,121 @@ var Zone$1 = loadZone();
 patchCommon(Zone$1);
 patchBrowser(Zone$1);
 
+// src/browser/supabase.ts
+var SUPABASE_DOMAIN = ".supabase.co";
+function isSupabaseURL(url) {
+  try {
+    const u = new URL(url);
+    return u.hostname.endsWith(SUPABASE_DOMAIN);
+  } catch {
+    return false;
+  }
+}
+function parseSupabaseURL(url, method) {
+  let u;
+  try {
+    u = new URL(url);
+  } catch {
+    return null;
+  }
+  if (!u.hostname.endsWith(SUPABASE_DOMAIN)) return null;
+  const ref = u.hostname.replace(SUPABASE_DOMAIN, "");
+  const path = u.pathname;
+  const segments = path.split("/").filter(Boolean);
+  if (segments[0] === "rest" && segments[1] === "v1" && segments[2]) {
+    const table = segments[2];
+    const op = restMethodToOp(method);
+    const select = u.searchParams.get("select") || "*";
+    const filters = extractFilters(u.searchParams);
+    const detail = op === "SELECT" ? `${op} ${select} FROM ${table}` : `${op} ${table}`;
+    return { ref, service: "postgrest", operation: op, table, detail: filters ? `${detail} WHERE ${filters}` : detail };
+  }
+  if (segments[0] === "auth" && segments[1] === "v1") {
+    const action = segments[2] || "session";
+    const op = authActionToOp(action);
+    return { ref, service: "auth", operation: op, table: "", detail: `AUTH ${op}` };
+  }
+  if (segments[0] === "storage" && segments[1] === "v1") {
+    const subCmd = segments[2] || "object";
+    const bucket = segments[3] || "";
+    const filePath = segments.slice(4).join("/");
+    const op = `${method.toUpperCase()} ${subCmd}`;
+    return { ref, service: "storage", operation: op, table: "", detail: bucket ? `STORAGE ${op} ${bucket}/${filePath}` : `STORAGE ${op}` };
+  }
+  if (segments[0] === "realtime") {
+    return { ref, service: "realtime", operation: "subscribe", table: "", detail: "REALTIME subscribe" };
+  }
+  if (segments[0] === "functions" && segments[1] === "v1" && segments[2]) {
+    const fnName = segments[2];
+    return { ref, service: "edge-function", operation: `invoke:${fnName}`, table: "", detail: `EDGE FUNCTION ${fnName}` };
+  }
+  return { ref, service: "unknown", operation: method.toUpperCase(), table: "", detail: `${method.toUpperCase()} ${path}` };
+}
+function restMethodToOp(method) {
+  switch (method.toUpperCase()) {
+    case "GET":
+      return "SELECT";
+    case "POST":
+      return "INSERT";
+    case "PATCH":
+      return "UPDATE";
+    case "PUT":
+      return "UPSERT";
+    case "DELETE":
+      return "DELETE";
+    default:
+      return method.toUpperCase();
+  }
+}
+function authActionToOp(action) {
+  switch (action) {
+    case "token":
+      return "login";
+    case "signup":
+      return "signup";
+    case "logout":
+      return "logout";
+    case "recover":
+      return "recover";
+    case "magiclink":
+      return "magic_link";
+    case "otp":
+      return "otp";
+    case "user":
+      return "get_user";
+    case "callback":
+      return "oauth_callback";
+    default:
+      return action;
+  }
+}
+function extractFilters(params) {
+  const filters = [];
+  for (const [key, value] of params.entries()) {
+    if (key === "select" || key === "apikey" || key === "order" || key === "limit" || key === "offset") continue;
+    const match = value.match(/^(eq|neq|gt|gte|lt|lte|like|ilike|is|in|cs|cd|not)\.(.+)/);
+    if (match) {
+      filters.push(`${key} ${match[1]} ${match[2]}`);
+    }
+  }
+  return filters.join(" AND ");
+}
+function enrichSupabaseSpan(span, url, method) {
+  const parsed = parseSupabaseURL(url, method);
+  if (!parsed) return;
+  span.setAttribute("supabase.ref", parsed.ref);
+  span.setAttribute("supabase.service", parsed.service);
+  span.setAttribute("supabase.operation", parsed.operation);
+  span.setAttribute("supabase.detail", parsed.detail);
+  span.setAttribute("peer.service", `supabase.${parsed.service}`);
+  if (parsed.service === "postgrest") {
+    span.setAttribute("db.system", "postgresql");
+    span.setAttribute("db.operation", parsed.operation);
+    if (parsed.table) span.setAttribute("db.sql.table", parsed.table);
+  }
+  span.updateName(`supabase.${parsed.service} ${parsed.detail}`);
+}
+
 // src/core/otel-web-setup.ts
 function setupOtelWeb(config) {
   const baseUrl = (config.ingestBaseUrl || "https://ingest.obtrace.ai").replace(/\/$/, "");
@@ -27815,14 +29712,33 @@ function setupOtelWeb(config) {
     ]
   });
   metrics.setGlobalMeterProvider(meterProvider);
+  const logExporter = new OTLPLogExporter({
+    url: `${baseUrl}/otlp/v1/logs`,
+    headers: authHeaders
+  });
+  const loggerProvider = new LoggerProvider({
+    resource,
+    processors: [new BatchLogRecordProcessor(logExporter)]
+  });
   const ingestPattern = new RegExp(`^${baseUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`);
   const instrumentations = [];
+  const applySupabaseAttrs = (span, req, _result) => {
+    try {
+      const url = typeof req === "string" ? req : req instanceof URL ? req.href : req?.url || "";
+      const method = req?.method || "GET";
+      if (url && isSupabaseURL(url)) {
+        enrichSupabaseSpan(span, url, method);
+      }
+    } catch {
+    }
+  };
   if (config.instrumentGlobalFetch !== false) {
     instrumentations.push(
       new FetchInstrumentation({
         propagateTraceHeaderCorsUrls: /.*/,
         ignoreUrls: [ingestPattern],
-        clearTimingResources: true
+        clearTimingResources: true,
+        applyCustomAttributesOnSpan: applySupabaseAttrs
       })
     );
   }
@@ -27841,8 +29757,8 @@ function setupOtelWeb(config) {
     tracerProvider,
     instrumentations
   });
-  const tracer = trace.getTracer("@obtrace/sdk-browser", "2.1.0");
-  const meter = metrics.getMeter("@obtrace/sdk-browser", "2.1.0");
+  const tracer = trace.getTracer("@obtrace/sdk-browser", "2.4.0");
+  const meter = metrics.getMeter("@obtrace/sdk-browser", "2.4.0");
   const forceFlush = async () => {
     try {
       await tracerProvider.forceFlush();
@@ -27852,13 +29768,18 @@ function setupOtelWeb(config) {
       await meterProvider.forceFlush();
     } catch {
     }
+    try {
+      await loggerProvider.forceFlush();
+    } catch {
+    }
   };
   const shutdown = async () => {
     await forceFlush();
     await tracerProvider.shutdown();
     await meterProvider.shutdown();
+    await loggerProvider.shutdown();
   };
-  return { tracer, meter, shutdown, forceFlush };
+  return { tracer, meter, loggerProvider, shutdown, forceFlush };
 }
 
 // src/browser/breadcrumbs.ts
@@ -27900,65 +29821,93 @@ function installClickBreadcrumbs() {
 }
 
 // src/browser/errors.ts
-function installBrowserErrorHooks(tracer, sessionId) {
+var processing = false;
+function installBrowserErrorHooks(tracer, logger, sessionId) {
   if (typeof window === "undefined") {
     return () => void 0;
   }
   const onError = (ev) => {
+    if (processing) return;
     const message = ev.message || "window.error";
     addBreadcrumb({ timestamp: Date.now(), category: "error", message, level: "error" });
     try {
+      processing = true;
       const breadcrumbs = getBreadcrumbs();
       const stack = ev.error instanceof Error ? ev.error.stack || "" : "";
-      const span = tracer.startSpan("browser.error", {
+      const errorType = ev.error?.constructor?.name || "Error";
+      const attrs = {
+        "error.message": message,
+        "error.file": ev.filename || "",
+        "error.line": ev.lineno || 0,
+        "error.column": ev.colno || 0,
+        "error.stack": stack.slice(0, 4096),
+        "error.type": errorType,
+        "breadcrumbs.count": breadcrumbs.length,
+        "breadcrumbs.json": JSON.stringify(breadcrumbs.slice(-20)),
+        ...sessionId ? { "session.id": sessionId } : {}
+      };
+      logger.emit({
+        severityNumber: SeverityNumber.ERROR,
+        severityText: "ERROR",
+        body: message,
         attributes: {
-          "error.message": message,
-          "error.file": ev.filename || "",
-          "error.line": ev.lineno || 0,
-          "error.column": ev.colno || 0,
-          "error.stack": stack.slice(0, 4096),
-          "error.type": ev.error?.constructor?.name || "Error",
-          "breadcrumbs.count": breadcrumbs.length,
-          "breadcrumbs.json": JSON.stringify(breadcrumbs.slice(-20)),
-          ...sessionId ? { "session.id": sessionId } : {}
+          "log.source": "window.error",
+          ...attrs
         }
       });
+      const span = tracer.startSpan("browser.error", { attributes: attrs });
       span.setStatus({ code: SpanStatusCode.ERROR, message });
       if (ev.error instanceof Error) {
         span.recordException(ev.error);
       }
       span.end();
     } catch {
+    } finally {
+      processing = false;
     }
   };
   const onRejection = (ev) => {
+    if (processing) return;
     let reason;
     let stack = "";
+    let errorType = "UnhandledRejection";
     if (ev.reason instanceof Error) {
       reason = `${ev.reason.name}: ${ev.reason.message}`;
       stack = ev.reason.stack || "";
+      errorType = ev.reason.constructor?.name || "Error";
     } else {
       reason = typeof ev.reason === "string" ? ev.reason : JSON.stringify(ev.reason ?? {});
     }
     addBreadcrumb({ timestamp: Date.now(), category: "error", message: reason, level: "error" });
     try {
+      processing = true;
       const breadcrumbs = getBreadcrumbs();
-      const span = tracer.startSpan("browser.unhandledrejection", {
+      const attrs = {
+        "error.message": reason,
+        "error.stack": stack.slice(0, 4096),
+        "error.type": errorType,
+        "breadcrumbs.count": breadcrumbs.length,
+        "breadcrumbs.json": JSON.stringify(breadcrumbs.slice(-20)),
+        ...sessionId ? { "session.id": sessionId } : {}
+      };
+      logger.emit({
+        severityNumber: SeverityNumber.ERROR,
+        severityText: "ERROR",
+        body: reason,
         attributes: {
-          "error.message": reason,
-          "error.stack": stack.slice(0, 4096),
-          "error.type": ev.reason?.constructor?.name || "UnhandledRejection",
-          "breadcrumbs.count": breadcrumbs.length,
-          "breadcrumbs.json": JSON.stringify(breadcrumbs.slice(-20)),
-          ...sessionId ? { "session.id": sessionId } : {}
+          "log.source": "unhandledrejection",
+          ...attrs
         }
       });
+      const span = tracer.startSpan("browser.unhandledrejection", { attributes: attrs });
       span.setStatus({ code: SpanStatusCode.ERROR, message: reason });
       if (ev.reason instanceof Error) {
         span.recordException(ev.reason);
       }
       span.end();
     } catch {
+    } finally {
+      processing = false;
     }
   };
   window.addEventListener("error", onError);
@@ -28235,9 +30184,17 @@ var LEVEL_MAP = {
   warn: "warn",
   error: "error"
 };
+var SEVERITY_MAP = {
+  debug: SeverityNumber.DEBUG,
+  log: SeverityNumber.INFO,
+  info: SeverityNumber.INFO,
+  warn: SeverityNumber.WARN,
+  error: SeverityNumber.ERROR
+};
 var patched = false;
 var originals = {};
-function installConsoleCapture(tracer, sessionId) {
+var emitting = false;
+function installConsoleCapture(tracer, logger, sessionId) {
   if (patched || typeof console === "undefined") return () => {
   };
   patched = true;
@@ -28249,7 +30206,9 @@ function installConsoleCapture(tracer, sessionId) {
     const level = LEVEL_MAP[method];
     console[method] = (...args) => {
       original(...args);
+      if (emitting) return;
       try {
+        emitting = true;
         let message;
         let attrs = {};
         const safeStringify = (v) => {
@@ -28293,21 +30252,32 @@ function installConsoleCapture(tracer, sessionId) {
           }
         }
         addBreadcrumb({ timestamp: Date.now(), category: `console.${method}`, message, level, data: attrs });
-        const spanName = method === "error" && (isErrorObj || attrs["error.stack"]) ? "browser.error" : "browser.console";
-        const span = tracer.startSpan(spanName, {
+        logger.emit({
+          severityNumber: SEVERITY_MAP[method] ?? SeverityNumber.INFO,
+          severityText: level.toUpperCase(),
+          body: message.slice(0, 4096),
           attributes: {
-            "log.severity": level.toUpperCase(),
-            "log.message": message.slice(0, 1024),
             "session.id": sessionId,
+            "log.source": "console",
             ...attrs
           }
         });
         if (method === "error") {
+          const spanName = isErrorObj || attrs["error.stack"] ? "browser.error" : "browser.console";
+          const span = tracer.startSpan(spanName, {
+            attributes: {
+              "error.message": message.slice(0, 1024),
+              "session.id": sessionId,
+              ...attrs
+            }
+          });
           span.setStatus({ code: SpanStatusCode.ERROR, message: message.slice(0, 1024) });
           if (isErrorObj) span.recordException(firstArg);
+          span.end();
         }
-        span.end();
       } catch {
+      } finally {
+        emitting = false;
       }
     };
   }
@@ -28390,14 +30360,19 @@ function installResourceTiming(meter) {
   };
   const gauge = meter.createGauge("browser.resource.duration", { unit: "ms" });
   const observer = new PerformanceObserver((list2) => {
-    for (const entry of list2.getEntries()) {
-      const res = entry;
-      if (res.duration < 100) continue;
-      gauge.record(res.duration, {
-        "resource.type": res.initiatorType || "other",
-        "resource.name": res.name.split("?")[0].split("/").pop() || res.name.slice(0, 80),
-        "resource.transfer_size": res.transferSize || 0
-      });
+    try {
+      for (const entry of list2.getEntries()) {
+        const res = entry;
+        if (res.duration < 100) continue;
+        const name = typeof res.name === "string" ? res.name : "";
+        const shortName = name.split("?")[0].split("/").pop() || name.slice(0, 80) || "unknown";
+        gauge.record(res.duration, {
+          "resource.type": String(res.initiatorType || "other"),
+          "resource.name": String(shortName),
+          "resource.transfer_size": Number(res.transferSize) || 0
+        });
+      }
+    } catch {
     }
   });
   try {
@@ -28454,6 +30429,127 @@ function installMemoryTracking(meter) {
   return () => clearInterval(timer);
 }
 
+// src/browser/supabase-intercept.ts
+function installSupabaseFetchInterceptor(tracer, sessionId) {
+  if (typeof window === "undefined" || typeof window.fetch === "undefined") return () => {
+  };
+  const originalFetch = window.fetch;
+  window.fetch = async function(input2, init) {
+    const url = typeof input2 === "string" ? input2 : input2 instanceof URL ? input2.href : input2 instanceof Request ? input2.url : "";
+    if (!url || !isSupabaseURL(url)) {
+      return originalFetch.call(this, input2, init);
+    }
+    const method = init?.method || (input2 instanceof Request ? input2.method : "GET") || "GET";
+    const parsed = parseSupabaseURL(url, method);
+    if (!parsed) {
+      return originalFetch.call(this, input2, init);
+    }
+    const rootSpan = tracer.startSpan(`supabase.${parsed.service} ${parsed.detail}`, {
+      attributes: {
+        "supabase.ref": parsed.ref,
+        "supabase.service": parsed.service,
+        "supabase.operation": parsed.operation,
+        "supabase.detail": parsed.detail,
+        "http.method": method.toUpperCase(),
+        "http.url": url.split("?")[0],
+        "peer.service": `supabase.${parsed.service}`,
+        "session.id": sessionId,
+        ...parsed.service === "postgrest" ? {
+          "db.system": "postgresql",
+          "db.operation": parsed.operation,
+          "db.sql.table": parsed.table
+        } : {}
+      }
+    });
+    const rootCtx = trace.setSpan(context.active(), rootSpan);
+    const startMs = performance.now();
+    try {
+      const response = await originalFetch.call(this, input2, init);
+      const durationMs = performance.now() - startMs;
+      rootSpan.setAttribute("http.status_code", response.status);
+      rootSpan.setAttribute("supabase.duration_ms", Math.round(durationMs));
+      context.with(rootCtx, () => {
+        createChildSpans(tracer, parsed, method, response.status, durationMs, sessionId);
+      });
+      if (response.status >= 400) {
+        rootSpan.setStatus({ code: SpanStatusCode.ERROR, message: `HTTP ${response.status}` });
+        addBreadcrumb({ timestamp: Date.now(), category: "supabase", message: `${parsed.detail} \u2192 ${response.status}`, level: "error" });
+      } else {
+        rootSpan.setStatus({ code: SpanStatusCode.OK });
+        addBreadcrumb({ timestamp: Date.now(), category: "supabase", message: `${parsed.detail} \u2192 ${response.status} (${Math.round(durationMs)}ms)`, level: "info" });
+      }
+      rootSpan.end();
+      return response;
+    } catch (err) {
+      rootSpan.setStatus({ code: SpanStatusCode.ERROR, message: err instanceof Error ? err.message : "fetch failed" });
+      if (err instanceof Error) rootSpan.recordException(err);
+      rootSpan.end();
+      addBreadcrumb({ timestamp: Date.now(), category: "supabase", message: `${parsed.detail} \u2192 FAILED`, level: "error" });
+      throw err;
+    }
+  };
+  return () => {
+    window.fetch = originalFetch;
+  };
+}
+function createChildSpans(tracer, parsed, method, status, _durationMs, sessionId) {
+  const synth = { "session.id": sessionId, "supabase.ref": parsed.ref, "span.synthetic": "true" };
+  const gatewaySpan = tracer.startSpan("supabase.gateway", {
+    attributes: {
+      ...synth,
+      "http.method": method.toUpperCase(),
+      "http.status_code": status,
+      "peer.service": "supabase.kong"
+    }
+  });
+  const gatewayCtx = trace.setSpan(context.active(), gatewaySpan);
+  context.with(gatewayCtx, () => {
+    if (parsed.service === "postgrest") {
+      const dbSpan = tracer.startSpan("supabase.db.query", {
+        attributes: {
+          ...synth,
+          "db.system": "postgresql",
+          "db.operation": parsed.operation,
+          "db.sql.table": parsed.table,
+          "db.statement": parsed.detail,
+          "peer.service": "supabase.postgresql"
+        }
+      });
+      if (status >= 400) dbSpan.setStatus({ code: SpanStatusCode.ERROR, message: `HTTP ${status}` });
+      else dbSpan.setStatus({ code: SpanStatusCode.OK });
+      dbSpan.end();
+    }
+    if (parsed.service === "auth") {
+      const authSpan = tracer.startSpan("supabase.auth." + parsed.operation, {
+        attributes: { ...synth, "auth.operation": parsed.operation, "peer.service": "supabase.gotrue" }
+      });
+      if (status >= 400) authSpan.setStatus({ code: SpanStatusCode.ERROR, message: `HTTP ${status}` });
+      else authSpan.setStatus({ code: SpanStatusCode.OK });
+      authSpan.end();
+    }
+    if (parsed.service === "storage") {
+      const storageSpan = tracer.startSpan("supabase.storage." + parsed.operation, {
+        attributes: { ...synth, "storage.operation": parsed.operation, "peer.service": "supabase.storage" }
+      });
+      if (status >= 400) storageSpan.setStatus({ code: SpanStatusCode.ERROR, message: `HTTP ${status}` });
+      else storageSpan.setStatus({ code: SpanStatusCode.OK });
+      storageSpan.end();
+    }
+    if (parsed.service === "edge-function") {
+      const fnName = parsed.operation.replace("invoke:", "");
+      const fnSpan = tracer.startSpan("supabase.function." + fnName, {
+        attributes: { ...synth, "faas.name": fnName, "faas.trigger": "http", "peer.service": "supabase.edge-runtime" }
+      });
+      if (status >= 400) fnSpan.setStatus({ code: SpanStatusCode.ERROR, message: `HTTP ${status}` });
+      else fnSpan.setStatus({ code: SpanStatusCode.OK });
+      fnSpan.end();
+    }
+  });
+  if (status >= 400) gatewaySpan.setStatus({ code: SpanStatusCode.ERROR, message: `HTTP ${status}` });
+  else gatewaySpan.setStatus({ code: SpanStatusCode.OK });
+  gatewaySpan.end();
+}
+
 // src/browser/index.ts
 var instances = /* @__PURE__ */ new Set();
 var replayBuffers = /* @__PURE__ */ new Set();
@@ -28558,22 +30654,6 @@ function teardownSharedRrwebRecording() {
   }
   rrwebRecording = false;
 }
-function severityToNumber(level) {
-  switch (level) {
-    case "debug":
-      return 5;
-    case "info":
-      return 9;
-    case "warn":
-      return 13;
-    case "error":
-      return 17;
-    case "fatal":
-      return 21;
-    default:
-      return 9;
-  }
-}
 function userAttrs() {
   if (!currentUser) return {};
   const attrs = {};
@@ -28600,6 +30680,7 @@ function initBrowserSDK(config) {
   const otel = setupOtelWeb({ ...config, tracesSampleRate: sampleRate, sessionId: replay.sessionId });
   const tracer = otel.tracer;
   const meter = otel.meter;
+  const logger = otel.loggerProvider.getLogger("@obtrace/sdk-browser", "2.4.0");
   const client = new ObtraceClient({
     ...config,
     replay: {
@@ -28640,14 +30721,15 @@ function initBrowserSDK(config) {
   }).catch(() => {
   });
   if (config.vitals?.enabled !== false) cleanups.push(installWebVitals(meter, !!config.vitals?.reportAllChanges));
-  cleanups.push(installBrowserErrorHooks(tracer, replay.sessionId));
+  cleanups.push(installBrowserErrorHooks(tracer, logger, replay.sessionId));
   cleanups.push(installClickBreadcrumbs());
   cleanups.push(installClickTracking(tracer, replay.sessionId));
   cleanups.push(installResourceTiming(meter));
   cleanups.push(installLongTaskDetection(tracer));
   cleanups.push(installMemoryTracking(meter));
+  cleanups.push(installSupabaseFetchInterceptor(tracer, replay.sessionId));
   if (config.captureConsole !== false) {
-    cleanups.push(installConsoleCapture(tracer, replay.sessionId));
+    cleanups.push(installConsoleCapture(tracer, logger, replay.sessionId));
   }
   cleanups.push(installOfflineSupport());
   if (shouldReplay && config.replay?.enabled !== false && typeof window !== "undefined") {
@@ -28694,21 +30776,40 @@ function initBrowserSDK(config) {
     window.addEventListener("beforeunload", onBeforeUnload);
     cleanups.push(() => window.removeEventListener("beforeunload", onBeforeUnload));
   }
+  const sevToOtel = {
+    debug: SeverityNumber.DEBUG,
+    info: SeverityNumber.INFO,
+    warn: SeverityNumber.WARN,
+    error: SeverityNumber.ERROR,
+    fatal: SeverityNumber.FATAL
+  };
   const log = (level, message, context2) => {
     addBreadcrumb({ timestamp: Date.now(), category: "log", message, level: level === "fatal" ? "error" : level });
-    const span = tracer.startSpan("browser.log", {
+    logger.emit({
+      severityNumber: sevToOtel[level] ?? SeverityNumber.INFO,
+      severityText: level.toUpperCase(),
+      body: message.slice(0, 4096),
       attributes: {
-        "log.severity": level.toUpperCase(),
-        "log.severity_number": severityToNumber(level),
-        "log.message": message,
         "session.id": replay.sessionId,
+        "log.source": "sdk",
         ...userAttrs(),
         ...context2?.traceId ? { "obtrace.trace_id": context2.traceId } : {},
         ...context2?.attrs
       }
     });
-    if (level === "error" || level === "fatal") span.setStatus({ code: SpanStatusCode.ERROR, message });
-    span.end();
+    if (level === "error" || level === "fatal") {
+      const span = tracer.startSpan("browser.error", {
+        attributes: {
+          "error.message": message,
+          "session.id": replay.sessionId,
+          ...userAttrs(),
+          ...context2?.traceId ? { "obtrace.trace_id": context2.traceId } : {},
+          ...context2?.attrs
+        }
+      });
+      span.setStatus({ code: SpanStatusCode.ERROR, message });
+      span.end();
+    }
   };
   const metricFn = (name, value, unit, context2) => {
     const gauge = meter.createGauge(name, { unit: unit ?? "1" });
@@ -28716,11 +30817,26 @@ function initBrowserSDK(config) {
   };
   const captureException = (error, context2) => {
     const msg = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+    const stack = error instanceof Error ? (error.stack || "").slice(0, 4096) : "";
     const breadcrumbs = getBreadcrumbs();
     addBreadcrumb({ timestamp: Date.now(), category: "error", message: msg, level: "error" });
+    logger.emit({
+      severityNumber: SeverityNumber.ERROR,
+      severityText: "ERROR",
+      body: msg,
+      attributes: {
+        "session.id": replay.sessionId,
+        "log.source": "exception",
+        "error.stack": stack,
+        "error.type": error instanceof Error ? error.name : "Error",
+        ...userAttrs(),
+        ...context2?.attrs
+      }
+    });
     const span = tracer.startSpan("browser.exception", {
       attributes: {
         "error.message": msg,
+        "error.stack": stack,
         "session.id": replay.sessionId,
         "breadcrumbs.count": breadcrumbs.length,
         "breadcrumbs.json": JSON.stringify(breadcrumbs.slice(-20)),