@superblocksteam/library 2.0.26-next.2 → 2.0.26-next.3

package/dist/logs-DWaPDDub.js

@@ -0,0 +1,1475 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { c as createContextKey, d as diag, a as context, t as trace, i as isSpanContextValid, b as defaultResource, r as resourceFromAttributes, L as LibraryEarlyConsoleBuffer, A as ATTR_SERVICE_NAME } from "./index-CdGno8TV.js";
+class NoopLogger {
+  emit(_logRecord) {
+  }
+}
+const NOOP_LOGGER = new NoopLogger();
+const SUPPRESS_TRACING_KEY = createContextKey("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+function suppressTracing(context2) {
+  return context2.setValue(SUPPRESS_TRACING_KEY, true);
+}
+function isAttributeValue(val) {
+  if (val == null) {
+    return true;
+  }
+  if (Array.isArray(val)) {
+    return isHomogeneousAttributeValueArray(val);
+  }
+  return isValidPrimitiveAttributeValue(val);
+}
+function isHomogeneousAttributeValueArray(arr) {
+  let type;
+  for (const element of arr) {
+    if (element == null)
+      continue;
+    if (!type) {
+      if (isValidPrimitiveAttributeValue(element)) {
+        type = typeof element;
+        continue;
+      }
+      return false;
+    }
+    if (typeof element === type) {
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function isValidPrimitiveAttributeValue(val) {
+  switch (typeof val) {
+    case "number":
+    case "boolean":
+    case "string":
+      return true;
+  }
+  return false;
+}
+function loggingErrorHandler() {
+  return (ex) => {
+    diag.error(stringifyException(ex));
+  };
+}
+function stringifyException(ex) {
+  if (typeof ex === "string") {
+    return ex;
+  } else {
+    return JSON.stringify(flattenException(ex));
+  }
+}
+function flattenException(ex) {
+  const result = {};
+  let current = ex;
+  while (current !== null) {
+    Object.getOwnPropertyNames(current).forEach((propertyName) => {
+      if (result[propertyName])
+        return;
+      const value = current[propertyName];
+      if (value) {
+        result[propertyName] = String(value);
+      }
+    });
+    current = Object.getPrototypeOf(current);
+  }
+  return result;
+}
+let delegateHandler = loggingErrorHandler();
+function globalErrorHandler(ex) {
+  try {
+    delegateHandler(ex);
+  } catch {
+  }
+}
+function getNumberFromEnv(_) {
+  return void 0;
+}
+const otperformance = performance;
+function unrefTimer(_timer) {
+}
+const NANOSECOND_DIGITS = 9;
+const NANOSECOND_DIGITS_IN_MILLIS = 6;
+const MILLISECONDS_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS_IN_MILLIS);
+const SECOND_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS);
+function millisToHrTime(epochMillis) {
+  const epochSeconds = epochMillis / 1e3;
+  const seconds = Math.trunc(epochSeconds);
+  const nanos = Math.round(epochMillis % 1e3 * MILLISECONDS_TO_NANOSECONDS);
+  return [seconds, nanos];
+}
+function getTimeOrigin() {
+  let timeOrigin = otperformance.timeOrigin;
+  if (typeof timeOrigin !== "number") {
+    const perf = otperformance;
+    timeOrigin = perf.timing && perf.timing.fetchStart;
+  }
+  return timeOrigin;
+}
+function hrTime(performanceNow) {
+  const timeOrigin = millisToHrTime(getTimeOrigin());
+  const now = millisToHrTime(typeof performanceNow === "number" ? performanceNow : otperformance.now());
+  return addHrTimes(timeOrigin, now);
+}
+function timeInputToHrTime(time) {
+  if (isTimeInputHrTime(time)) {
+    return time;
+  } else if (typeof time === "number") {
+    if (time < getTimeOrigin()) {
+      return hrTime(time);
+    } else {
+      return millisToHrTime(time);
+    }
+  } else if (time instanceof Date) {
+    return millisToHrTime(time.getTime());
+  } else {
+    throw TypeError("Invalid input type");
+  }
+}
+function hrTimeToNanoseconds(time) {
+  return time[0] * SECOND_TO_NANOSECONDS + time[1];
+}
+function isTimeInputHrTime(value) {
+  return Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number";
+}
+function addHrTimes(time1, time2) {
+  const out = [time1[0] + time2[0], time1[1] + time2[1]];
+  if (out[1] >= SECOND_TO_NANOSECONDS) {
+    out[1] -= SECOND_TO_NANOSECONDS;
+    out[0] += 1;
+  }
+  return out;
+}
+var ExportResultCode;
+(function(ExportResultCode2) {
+  ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
+  ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
+})(ExportResultCode || (ExportResultCode = {}));
+const objectTag = "[object Object]";
+const nullTag = "[object Null]";
+const undefinedTag = "[object Undefined]";
+const funcProto = Function.prototype;
+const funcToString = funcProto.toString;
+const objectCtorString = funcToString.call(Object);
+const getPrototypeOf = Object.getPrototypeOf;
+const objectProto = Object.prototype;
+const hasOwnProperty = objectProto.hasOwnProperty;
+const symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+const nativeObjectToString = objectProto.toString;
+function isPlainObject(value) {
+  if (!isObjectLike(value) || baseGetTag(value) !== objectTag) {
+    return false;
+  }
+  const proto = getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) === objectCtorString;
+}
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+function getRawTag(value) {
+  const isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  let unmasked = false;
+  try {
+    value[symToStringTag] = void 0;
+    unmasked = true;
+  } catch (e) {
+  }
+  const result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+const MAX_LEVEL = 20;
+function merge(...args) {
+  let result = args.shift();
+  const objects = /* @__PURE__ */ new WeakMap();
+  while (args.length > 0) {
+    result = mergeTwoObjects(result, args.shift(), 0, objects);
+  }
+  return result;
+}
+function takeValue(value) {
+  if (isArray(value)) {
+    return value.slice();
+  }
+  return value;
+}
+function mergeTwoObjects(one, two, level = 0, objects) {
+  let result;
+  if (level > MAX_LEVEL) {
+    return void 0;
+  }
+  level++;
+  if (isPrimitive(one) || isPrimitive(two) || isFunction(two)) {
+    result = takeValue(two);
+  } else if (isArray(one)) {
+    result = one.slice();
+    if (isArray(two)) {
+      for (let i = 0, j = two.length; i < j; i++) {
+        result.push(takeValue(two[i]));
+      }
+    } else if (isObject(two)) {
+      const keys = Object.keys(two);
+      for (let i = 0, j = keys.length; i < j; i++) {
+        const key = keys[i];
+        result[key] = takeValue(two[key]);
+      }
+    }
+  } else if (isObject(one)) {
+    if (isObject(two)) {
+      if (!shouldMerge(one, two)) {
+        return two;
+      }
+      result = Object.assign({}, one);
+      const keys = Object.keys(two);
+      for (let i = 0, j = keys.length; i < j; i++) {
+        const key = keys[i];
+        const twoValue = two[key];
+        if (isPrimitive(twoValue)) {
+          if (typeof twoValue === "undefined") {
+            delete result[key];
+          } else {
+            result[key] = twoValue;
+          }
+        } else {
+          const obj1 = result[key];
+          const obj2 = twoValue;
+          if (wasObjectReferenced(one, key, objects) || wasObjectReferenced(two, key, objects)) {
+            delete result[key];
+          } else {
+            if (isObject(obj1) && isObject(obj2)) {
+              const arr1 = objects.get(obj1) || [];
+              const arr2 = objects.get(obj2) || [];
+              arr1.push({ obj: one, key });
+              arr2.push({ obj: two, key });
+              objects.set(obj1, arr1);
+              objects.set(obj2, arr2);
+            }
+            result[key] = mergeTwoObjects(result[key], twoValue, level, objects);
+          }
+        }
+      }
+    } else {
+      result = two;
+    }
+  }
+  return result;
+}
+function wasObjectReferenced(obj, key, objects) {
+  const arr = objects.get(obj[key]) || [];
+  for (let i = 0, j = arr.length; i < j; i++) {
+    const info = arr[i];
+    if (info.key === key && info.obj === obj) {
+      return true;
+    }
+  }
+  return false;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isObject(value) {
+  return !isPrimitive(value) && !isArray(value) && !isFunction(value) && typeof value === "object";
+}
+function isPrimitive(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "undefined" || value instanceof Date || value instanceof RegExp || value === null;
+}
+function shouldMerge(one, two) {
+  if (!isPlainObject(one) || !isPlainObject(two)) {
+    return false;
+  }
+  return true;
+}
+class TimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, TimeoutError.prototype);
+  }
+}
+function callWithTimeout(promise, timeout) {
+  let timeoutHandle;
+  const timeoutPromise = new Promise(function timeoutFunction(_resolve, reject) {
+    timeoutHandle = setTimeout(function timeoutHandler() {
+      reject(new TimeoutError("Operation timed out."));
+    }, timeout);
+  });
+  return Promise.race([promise, timeoutPromise]).then((result) => {
+    clearTimeout(timeoutHandle);
+    return result;
+  }, (reason) => {
+    clearTimeout(timeoutHandle);
+    throw reason;
+  });
+}
+class Deferred {
+  constructor() {
+    __publicField(this, "_promise");
+    __publicField(this, "_resolve");
+    __publicField(this, "_reject");
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  get promise() {
+    return this._promise;
+  }
+  resolve(val) {
+    this._resolve(val);
+  }
+  reject(err) {
+    this._reject(err);
+  }
+}
+class BindOnceFuture {
+  constructor(_callback, _that) {
+    __publicField(this, "_callback");
+    __publicField(this, "_that");
+    __publicField(this, "_isCalled", false);
+    __publicField(this, "_deferred", new Deferred());
+    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;
+  }
+}
+function _export(exporter, arg) {
+  return new Promise((resolve) => {
+    context.with(suppressTracing(context.active()), () => {
+      exporter.export(arg, (result) => {
+        resolve(result);
+      });
+    });
+  });
+}
+const internal = {
+  _export
+};
+class OTLPExporterBase {
+  constructor(_delegate) {
+    __publicField(this, "_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();
+  }
+}
+class OTLPExporterError extends Error {
+  constructor(message, code, data) {
+    super(message);
+    __publicField(this, "code");
+    __publicField(this, "name", "OTLPExporterError");
+    __publicField(this, "data");
+    this.data = data;
+    this.code = code;
+  }
+}
+function validateTimeoutMillis(timeoutMillis) {
+  if (Number.isFinite(timeoutMillis) && timeoutMillis > 0) {
+    return timeoutMillis;
+  }
+  throw new Error(`Configuration: timeoutMillis is invalid, expected number greater than 0 (actual: '${timeoutMillis}')`);
+}
+function wrapStaticHeadersInFunction(headers) {
+  if (headers == null) {
+    return void 0;
+  }
+  return () => headers;
+}
+function mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
+  return {
+    timeoutMillis: validateTimeoutMillis(userProvidedConfiguration.timeoutMillis ?? fallbackConfiguration.timeoutMillis ?? defaultConfiguration.timeoutMillis),
+    concurrencyLimit: userProvidedConfiguration.concurrencyLimit ?? fallbackConfiguration.concurrencyLimit ?? defaultConfiguration.concurrencyLimit,
+    compression: userProvidedConfiguration.compression ?? fallbackConfiguration.compression ?? defaultConfiguration.compression
+  };
+}
+function getSharedConfigurationDefaults() {
+  return {
+    timeoutMillis: 1e4,
+    concurrencyLimit: 30,
+    compression: "none"
+  };
+}
+class BoundedQueueExportPromiseHandler {
+  /**
+   * @param concurrencyLimit maximum promises allowed in a queue at the same time.
+   */
+  constructor(concurrencyLimit) {
+    __publicField(this, "_concurrencyLimit");
+    __publicField(this, "_sendingPromises", []);
+    this._concurrencyLimit = concurrencyLimit;
+  }
+  pushPromise(promise) {
+    if (this.hasReachedLimit()) {
+      throw new Error("Concurrency Limit reached");
+    }
+    this._sendingPromises.push(promise);
+    const popPromise = () => {
+      const index = this._sendingPromises.indexOf(promise);
+      void this._sendingPromises.splice(index, 1);
+    };
+    promise.then(popPromise, popPromise);
+  }
+  hasReachedLimit() {
+    return this._sendingPromises.length >= this._concurrencyLimit;
+  }
+  async awaitAll() {
+    await Promise.all(this._sendingPromises);
+  }
+}
+function createBoundedQueueExportPromiseHandler(options) {
+  return new BoundedQueueExportPromiseHandler(options.concurrencyLimit);
+}
+function isPartialSuccessResponse(response) {
+  return Object.prototype.hasOwnProperty.call(response, "partialSuccess");
+}
+function createLoggingPartialSuccessResponseHandler() {
+  return {
+    handleResponse(response) {
+      if (response == null || !isPartialSuccessResponse(response) || response.partialSuccess == null || Object.keys(response.partialSuccess).length === 0) {
+        return;
+      }
+      diag.warn("Received Partial Success response:", JSON.stringify(response.partialSuccess));
+    }
+  };
+}
+class OTLPExportDelegate {
+  constructor(_transport, _serializer, _responseHandler, _promiseQueue, _timeout) {
+    __publicField(this, "_transport");
+    __publicField(this, "_serializer");
+    __publicField(this, "_responseHandler");
+    __publicField(this, "_promiseQueue");
+    __publicField(this, "_timeout");
+    __publicField(this, "_diagLogger");
+    this._transport = _transport;
+    this._serializer = _serializer;
+    this._responseHandler = _responseHandler;
+    this._promiseQueue = _promiseQueue;
+    this._timeout = _timeout;
+    this._diagLogger = diag.createComponentLogger({
+      namespace: "OTLPExportDelegate"
+    });
+  }
+  export(internalRepresentation, resultCallback) {
+    this._diagLogger.debug("items to be sent", internalRepresentation);
+    if (this._promiseQueue.hasReachedLimit()) {
+      resultCallback({
+        code: ExportResultCode.FAILED,
+        error: new Error("Concurrent export limit reached")
+      });
+      return;
+    }
+    const serializedRequest = this._serializer.serializeRequest(internalRepresentation);
+    if (serializedRequest == null) {
+      resultCallback({
+        code: ExportResultCode.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: ExportResultCode.SUCCESS
+        });
+        return;
+      } else if (response.status === "failure" && response.error) {
+        resultCallback({
+          code: ExportResultCode.FAILED,
+          error: response.error
+        });
+        return;
+      } else if (response.status === "retryable") {
+        resultCallback({
+          code: ExportResultCode.FAILED,
+          error: new OTLPExporterError("Export failed with retryable status")
+        });
+      } else {
+        resultCallback({
+          code: ExportResultCode.FAILED,
+          error: new OTLPExporterError("Export failed with unknown error")
+        });
+      }
+    }, (reason) => resultCallback({
+      code: ExportResultCode.FAILED,
+      error: reason
+    })));
+  }
+  forceFlush() {
+    return this._promiseQueue.awaitAll();
+  }
+  async shutdown() {
+    this._diagLogger.debug("shutdown started");
+    await this.forceFlush();
+    this._transport.shutdown();
+  }
+}
+function createOtlpExportDelegate(components, settings) {
+  return new OTLPExportDelegate(components.transport, components.serializer, createLoggingPartialSuccessResponseHandler(), components.promiseHandler, settings.timeout);
+}
+function createOtlpNetworkExportDelegate(options, serializer, transport) {
+  return createOtlpExportDelegate({
+    transport,
+    serializer,
+    promiseHandler: createBoundedQueueExportPromiseHandler(options)
+  }, { timeout: options.timeoutMillis });
+}
+function intValue(charCode) {
+  if (charCode >= 48 && charCode <= 57) {
+    return charCode - 48;
+  }
+  if (charCode >= 97 && charCode <= 102) {
+    return charCode - 87;
+  }
+  return charCode - 55;
+}
+function hexToBinary(hexStr) {
+  const buf = new Uint8Array(hexStr.length / 2);
+  let offset = 0;
+  for (let i = 0; i < hexStr.length; i += 2) {
+    const hi = intValue(hexStr.charCodeAt(i));
+    const lo = intValue(hexStr.charCodeAt(i + 1));
+    buf[offset++] = hi << 4 | lo;
+  }
+  return buf;
+}
+function hrTimeToNanos(hrTime2) {
+  const NANOSECONDS = BigInt(1e9);
+  return BigInt(hrTime2[0]) * NANOSECONDS + BigInt(hrTime2[1]);
+}
+function toLongBits(value) {
+  const low = Number(BigInt.asUintN(32, value));
+  const high = Number(BigInt.asUintN(32, value >> BigInt(32)));
+  return { low, high };
+}
+function encodeAsLongBits(hrTime2) {
+  const nanos = hrTimeToNanos(hrTime2);
+  return toLongBits(nanos);
+}
+function encodeAsString(hrTime2) {
+  const nanos = hrTimeToNanos(hrTime2);
+  return nanos.toString();
+}
+const encodeTimestamp = typeof BigInt !== "undefined" ? encodeAsString : hrTimeToNanoseconds;
+function identity(value) {
+  return value;
+}
+function optionalHexToBinary(str) {
+  if (str === void 0)
+    return void 0;
+  return hexToBinary(str);
+}
+const DEFAULT_ENCODER = {
+  encodeHrTime: encodeAsLongBits,
+  encodeSpanContext: hexToBinary,
+  encodeOptionalSpanContext: optionalHexToBinary
+};
+function getOtlpEncoder(options) {
+  if (options === void 0) {
+    return DEFAULT_ENCODER;
+  }
+  return {
+    encodeHrTime: encodeTimestamp,
+    encodeSpanContext: identity,
+    encodeOptionalSpanContext: identity
+  };
+}
+function createResource(resource) {
+  return {
+    attributes: toAttributes(resource.attributes),
+    droppedAttributesCount: 0
+  };
+}
+function createInstrumentationScope(scope) {
+  return {
+    name: scope.name,
+    version: scope.version
+  };
+}
+function toAttributes(attributes) {
+  return Object.keys(attributes).map((key) => toKeyValue(key, attributes[key]));
+}
+function toKeyValue(key, value) {
+  return {
+    key,
+    value: toAnyValue(value)
+  };
+}
+function toAnyValue(value) {
+  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: value };
+  if (Array.isArray(value))
+    return { arrayValue: { values: value.map(toAnyValue) } };
+  if (t === "object" && value != null)
+    return {
+      kvlistValue: {
+        values: Object.entries(value).map(([k, v]) => toKeyValue(k, v))
+      }
+    };
+  return {};
+}
+function createExportLogsServiceRequest(logRecords, options) {
+  const encoder = getOtlpEncoder(options);
+  return {
+    resourceLogs: logRecordsToResourceLogs(logRecords, encoder)
+  };
+}
+function createResourceMap(logRecords) {
+  const resourceMap = /* @__PURE__ */ new Map();
+  for (const record of logRecords) {
+    const { resource, instrumentationScope: { name, version = "", schemaUrl = "" } } = record;
+    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(record);
+  }
+  return resourceMap;
+}
+function logRecordsToResourceLogs(logRecords, encoder) {
+  const resourceMap = createResourceMap(logRecords);
+  return Array.from(resourceMap, ([resource, ismMap]) => ({
+    resource: createResource(resource),
+    scopeLogs: Array.from(ismMap, ([, scopeLogs]) => {
+      return {
+        scope: createInstrumentationScope(scopeLogs[0].instrumentationScope),
+        logRecords: scopeLogs.map((log) => toLogRecord(log, encoder)),
+        schemaUrl: scopeLogs[0].instrumentationScope.schemaUrl
+      };
+    }),
+    schemaUrl: void 0
+  }));
+}
+function toLogRecord(log, encoder) {
+  var _a, _b, _c;
+  return {
+    timeUnixNano: encoder.encodeHrTime(log.hrTime),
+    observedTimeUnixNano: encoder.encodeHrTime(log.hrTimeObserved),
+    severityNumber: toSeverityNumber(log.severityNumber),
+    severityText: log.severityText,
+    body: toAnyValue(log.body),
+    eventName: log.eventName,
+    attributes: toLogAttributes(log.attributes),
+    droppedAttributesCount: log.droppedAttributesCount,
+    flags: (_a = log.spanContext) == null ? void 0 : _a.traceFlags,
+    traceId: encoder.encodeOptionalSpanContext((_b = log.spanContext) == null ? void 0 : _b.traceId),
+    spanId: encoder.encodeOptionalSpanContext((_c = log.spanContext) == null ? void 0 : _c.spanId)
+  };
+}
+function toSeverityNumber(severityNumber) {
+  return severityNumber;
+}
+function toLogAttributes(attributes) {
+  return Object.keys(attributes).map((key) => toKeyValue(key, attributes[key]));
+}
+const JsonLogsSerializer = {
+  serializeRequest: (arg) => {
+    const request = createExportLogsServiceRequest(arg, {});
+    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));
+  }
+};
+const MAX_ATTEMPTS = 5;
+const INITIAL_BACKOFF = 1e3;
+const MAX_BACKOFF = 5e3;
+const BACKOFF_MULTIPLIER = 1.5;
+const JITTER = 0.2;
+function getJitter() {
+  return Math.random() * (2 * JITTER) - JITTER;
+}
+class RetryingTransport {
+  constructor(_transport) {
+    __publicField(this, "_transport");
+    this._transport = _transport;
+  }
+  retry(data, timeoutMillis, inMillis) {
+    return new Promise((resolve, reject) => {
+      setTimeout(() => {
+        this._transport.send(data, timeoutMillis).then(resolve, reject);
+      }, inMillis);
+    });
+  }
+  async send(data, timeoutMillis) {
+    const deadline = Date.now() + timeoutMillis;
+    let result = await this._transport.send(data, timeoutMillis);
+    let attempts = MAX_ATTEMPTS;
+    let nextBackoff = INITIAL_BACKOFF;
+    while (result.status === "retryable" && attempts > 0) {
+      attempts--;
+      const backoff = Math.max(Math.min(nextBackoff, MAX_BACKOFF) + getJitter(), 0);
+      nextBackoff = nextBackoff * BACKOFF_MULTIPLIER;
+      const retryInMillis = result.retryInMillis ?? backoff;
+      const remainingTimeoutMillis = deadline - Date.now();
+      if (retryInMillis > remainingTimeoutMillis) {
+        return result;
+      }
+      result = await this.retry(data, remainingTimeoutMillis, retryInMillis);
+    }
+    return result;
+  }
+  shutdown() {
+    return this._transport.shutdown();
+  }
+}
+function createRetryingTransport(options) {
+  return new RetryingTransport(options.transport);
+}
+function isExportRetryable(statusCode) {
+  const retryCodes = [429, 502, 503, 504];
+  return retryCodes.includes(statusCode);
+}
+function parseRetryAfterToMills(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;
+}
+class XhrTransport {
+  constructor(_parameters) {
+    __publicField(this, "_parameters");
+    this._parameters = _parameters;
+  }
+  send(data, timeoutMillis) {
+    return new Promise((resolve) => {
+      const xhr = new XMLHttpRequest();
+      xhr.timeout = timeoutMillis;
+      xhr.open("POST", this._parameters.url);
+      const headers = this._parameters.headers();
+      Object.entries(headers).forEach(([k, v]) => {
+        xhr.setRequestHeader(k, v);
+      });
+      xhr.ontimeout = (_) => {
+        resolve({
+          status: "failure",
+          error: new Error("XHR request timed out")
+        });
+      };
+      xhr.onreadystatechange = () => {
+        if (xhr.status >= 200 && xhr.status <= 299) {
+          diag.debug("XHR success");
+          resolve({
+            status: "success"
+          });
+        } else if (xhr.status && isExportRetryable(xhr.status)) {
+          resolve({
+            status: "retryable",
+            retryInMillis: parseRetryAfterToMills(xhr.getResponseHeader("Retry-After"))
+          });
+        } else if (xhr.status !== 0) {
+          resolve({
+            status: "failure",
+            error: new Error("XHR request failed with non-retryable status")
+          });
+        }
+      };
+      xhr.onabort = () => {
+        resolve({
+          status: "failure",
+          error: new Error("XHR request aborted")
+        });
+      };
+      xhr.onerror = () => {
+        resolve({
+          status: "failure",
+          error: new Error("XHR request errored")
+        });
+      };
+      xhr.send(data);
+    });
+  }
+  shutdown() {
+  }
+}
+function createXhrTransport(parameters) {
+  return new XhrTransport(parameters);
+}
+class SendBeaconTransport {
+  constructor(_params) {
+    __publicField(this, "_params");
+    this._params = _params;
+  }
+  send(data) {
+    return new Promise((resolve) => {
+      if (navigator.sendBeacon(this._params.url, new Blob([data], { type: this._params.blobType }))) {
+        diag.debug("SendBeacon success");
+        resolve({
+          status: "success"
+        });
+      } else {
+        resolve({
+          status: "failure",
+          error: new Error("SendBeacon failed")
+        });
+      }
+    });
+  }
+  shutdown() {
+  }
+}
+function createSendBeaconTransport(parameters) {
+  return new SendBeaconTransport(parameters);
+}
+function createOtlpXhrExportDelegate(options, serializer) {
+  return createOtlpNetworkExportDelegate(options, serializer, createRetryingTransport({
+    transport: createXhrTransport(options)
+  }));
+}
+function createOtlpSendBeaconExportDelegate(options, serializer) {
+  return createOtlpNetworkExportDelegate(options, serializer, createRetryingTransport({
+    transport: createSendBeaconTransport({
+      url: options.url,
+      blobType: options.headers()["Content-Type"]
+    })
+  }));
+}
+function validateAndNormalizeHeaders(partialHeaders) {
+  return () => {
+    const headers = {};
+    Object.entries((partialHeaders == null ? void 0 : partialHeaders()) ?? {}).forEach(([key, value]) => {
+      if (typeof value !== "undefined") {
+        headers[key] = String(value);
+      } else {
+        diag.warn(`Header "${key}" has invalid value (${value}) and will be ignored`);
+      }
+    });
+    return headers;
+  };
+}
+function mergeHeaders(userProvidedHeaders, fallbackHeaders, defaultHeaders) {
+  const requiredHeaders = {
+    ...defaultHeaders()
+  };
+  const headers = {};
+  return () => {
+    if (fallbackHeaders != null) {
+      Object.assign(headers, fallbackHeaders());
+    }
+    if (userProvidedHeaders != null) {
+      Object.assign(headers, userProvidedHeaders());
+    }
+    return Object.assign(headers, requiredHeaders);
+  };
+}
+function validateUserProvidedUrl(url) {
+  if (url == null) {
+    return void 0;
+  }
+  try {
+    new URL(url);
+    return url;
+  } catch {
+    throw new Error(`Configuration: Could not parse user-provided export URL: '${url}'`);
+  }
+}
+function mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
+  return {
+    ...mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration),
+    headers: mergeHeaders(validateAndNormalizeHeaders(userProvidedConfiguration.headers), fallbackConfiguration.headers, defaultConfiguration.headers),
+    url: validateUserProvidedUrl(userProvidedConfiguration.url) ?? fallbackConfiguration.url ?? defaultConfiguration.url,
+    agentOptions: userProvidedConfiguration.agentOptions ?? fallbackConfiguration.agentOptions ?? defaultConfiguration.agentOptions
+  };
+}
+function getHttpConfigurationDefaults(requiredHeaders, signalResourcePath) {
+  return {
+    ...getSharedConfigurationDefaults(),
+    headers: () => requiredHeaders,
+    url: "http://localhost:4318/" + signalResourcePath,
+    agentOptions: { keepAlive: true }
+  };
+}
+function convertLegacyBrowserHttpOptions(config, signalResourcePath, requiredHeaders) {
+  return mergeOtlpHttpConfigurationWithDefaults(
+    {
+      url: config.url,
+      timeoutMillis: config.timeoutMillis,
+      headers: wrapStaticHeadersInFunction(config.headers),
+      concurrencyLimit: config.concurrencyLimit
+    },
+    {},
+    // no fallback for browser case
+    getHttpConfigurationDefaults(requiredHeaders, signalResourcePath)
+  );
+}
+function createLegacyOtlpBrowserExportDelegate(config, serializer, signalResourcePath, requiredHeaders) {
+  const useXhr = !!config.headers || typeof navigator.sendBeacon !== "function";
+  const options = convertLegacyBrowserHttpOptions(config, signalResourcePath, requiredHeaders);
+  if (useXhr) {
+    return createOtlpXhrExportDelegate(options, serializer);
+  } else {
+    return createOtlpSendBeaconExportDelegate(options, serializer);
+  }
+}
+class OTLPLogExporter extends OTLPExporterBase {
+  constructor(config = {}) {
+    super(createLegacyOtlpBrowserExportDelegate(config, JsonLogsSerializer, "v1/logs", { "Content-Type": "application/json" }));
+  }
+}
+class LogRecordImpl {
+  constructor(_sharedState, instrumentationScope, logRecord) {
+    __publicField(this, "hrTime");
+    __publicField(this, "hrTimeObserved");
+    __publicField(this, "spanContext");
+    __publicField(this, "resource");
+    __publicField(this, "instrumentationScope");
+    __publicField(this, "attributes", {});
+    __publicField(this, "_severityText");
+    __publicField(this, "_severityNumber");
+    __publicField(this, "_body");
+    __publicField(this, "_eventName");
+    __publicField(this, "totalAttributesCount", 0);
+    __publicField(this, "_isReadonly", false);
+    __publicField(this, "_logRecordLimits");
+    const { timestamp, observedTimestamp, eventName, severityNumber, severityText, body, attributes = {}, context: context2 } = logRecord;
+    const now = Date.now();
+    this.hrTime = timeInputToHrTime(timestamp ?? now);
+    this.hrTimeObserved = timeInputToHrTime(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);
+  }
+  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.totalAttributesCount - Object.keys(this.attributes).length;
+  }
+  setAttribute(key, value) {
+    if (this._isLogRecordReadonly()) {
+      return this;
+    }
+    if (value === null) {
+      return this;
+    }
+    if (key.length === 0) {
+      diag.warn(`Invalid attribute key: ${key}`);
+      return this;
+    }
+    if (!isAttributeValue(value) && !(typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0)) {
+      diag.warn(`Invalid attribute value set for key: ${key}`);
+      return this;
+    }
+    this.totalAttributesCount += 1;
+    if (Object.keys(this.attributes).length >= this._logRecordLimits.attributeCountLimit && !Object.prototype.hasOwnProperty.call(this.attributes, key)) {
+      if (this.droppedAttributesCount === 1) {
+        diag.warn("Dropping extra attributes.");
+      }
+      return this;
+    }
+    if (isAttributeValue(value)) {
+      this.attributes[key] = this._truncateToSize(value);
+    } else {
+      this.attributes[key] = value;
+    }
+    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) {
+      diag.warn(`Attribute value limit must be positive, got ${limit}`);
+      return value;
+    }
+    if (typeof value === "string") {
+      return this._truncateToLimitUtil(value, limit);
+    }
+    if (Array.isArray(value)) {
+      return value.map((val) => typeof val === "string" ? this._truncateToLimitUtil(val, limit) : val);
+    }
+    return value;
+  }
+  _truncateToLimitUtil(value, limit) {
+    if (value.length <= limit) {
+      return value;
+    }
+    return value.substring(0, limit);
+  }
+  _isLogRecordReadonly() {
+    if (this._isReadonly) {
+      diag.warn("Can not execute the operation on emitted log record");
+    }
+    return this._isReadonly;
+  }
+}
+class Logger {
+  constructor(instrumentationScope, _sharedState) {
+    __publicField(this, "instrumentationScope");
+    __publicField(this, "_sharedState");
+    this.instrumentationScope = instrumentationScope;
+    this._sharedState = _sharedState;
+  }
+  emit(logRecord) {
+    const currentContext = logRecord.context || context.active();
+    const logRecordInstance = new LogRecordImpl(this._sharedState, this.instrumentationScope, {
+      context: currentContext,
+      ...logRecord
+    });
+    this._sharedState.activeProcessor.onEmit(logRecordInstance, currentContext);
+    logRecordInstance._makeReadonly();
+  }
+}
+function loadDefaultConfig() {
+  return {
+    forceFlushTimeoutMillis: 3e4,
+    logRecordLimits: {
+      attributeValueLengthLimit: Infinity,
+      attributeCountLimit: 128
+    },
+    includeTraceContext: true
+  };
+}
+function reconfigureLimits(logRecordLimits) {
+  return {
+    /**
+     * Reassign log record attribute count limit to use first non null value defined by user or use default value
+     */
+    attributeCountLimit: logRecordLimits.attributeCountLimit ?? getNumberFromEnv() ?? getNumberFromEnv() ?? 128,
+    /**
+     * Reassign log record attribute value length limit to use first non null value defined by user or use default value
+     */
+    attributeValueLengthLimit: logRecordLimits.attributeValueLengthLimit ?? getNumberFromEnv() ?? getNumberFromEnv() ?? Infinity
+  };
+}
+class NoopLogRecordProcessor {
+  forceFlush() {
+    return Promise.resolve();
+  }
+  onEmit(_logRecord, _context) {
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+}
+class MultiLogRecordProcessor {
+  constructor(processors, forceFlushTimeoutMillis) {
+    __publicField(this, "processors");
+    __publicField(this, "forceFlushTimeoutMillis");
+    this.processors = processors;
+    this.forceFlushTimeoutMillis = forceFlushTimeoutMillis;
+  }
+  async forceFlush() {
+    const timeout = this.forceFlushTimeoutMillis;
+    await Promise.all(this.processors.map((processor) => callWithTimeout(processor.forceFlush(), timeout)));
+  }
+  onEmit(logRecord, context2) {
+    this.processors.forEach((processors) => processors.onEmit(logRecord, context2));
+  }
+  async shutdown() {
+    await Promise.all(this.processors.map((processor) => processor.shutdown()));
+  }
+}
+class LoggerProviderSharedState {
+  constructor(resource, forceFlushTimeoutMillis, logRecordLimits, processors) {
+    __publicField(this, "resource");
+    __publicField(this, "forceFlushTimeoutMillis");
+    __publicField(this, "logRecordLimits");
+    __publicField(this, "processors");
+    __publicField(this, "loggers", /* @__PURE__ */ new Map());
+    __publicField(this, "activeProcessor");
+    __publicField(this, "registeredLogRecordProcessors", []);
+    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();
+    }
+  }
+}
+const DEFAULT_LOGGER_NAME = "unknown";
+class LoggerProvider {
+  constructor(config = {}) {
+    __publicField(this, "_shutdownOnce");
+    __publicField(this, "_sharedState");
+    const mergedConfig = merge({}, loadDefaultConfig(), config);
+    const resource = config.resource ?? defaultResource();
+    this._sharedState = new LoggerProviderSharedState(resource, mergedConfig.forceFlushTimeoutMillis, reconfigureLimits(mergedConfig.logRecordLimits), (config == null ? void 0 : config.processors) ?? []);
+    this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+  }
+  /**
+   * Get a logger with the configuration of the LoggerProvider.
+   */
+  getLogger(name, version, options) {
+    if (this._shutdownOnce.isCalled) {
+      diag.warn("A shutdown LoggerProvider cannot provide a Logger");
+      return NOOP_LOGGER;
+    }
+    if (!name) {
+      diag.warn("Logger requested without instrumentation scope name.");
+    }
+    const loggerName = name || DEFAULT_LOGGER_NAME;
+    const key = `${loggerName}@${version || ""}:${(options == null ? void 0 : options.schemaUrl) || ""}`;
+    if (!this._sharedState.loggers.has(key)) {
+      this._sharedState.loggers.set(key, new Logger({ name: loggerName, version, schemaUrl: options == null ? void 0 : 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) {
+      diag.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) {
+      diag.warn("shutdown may only be called once per LoggerProvider");
+      return this._shutdownOnce.promise;
+    }
+    return this._shutdownOnce.call();
+  }
+  _shutdown() {
+    return this._sharedState.activeProcessor.shutdown();
+  }
+}
+class BatchLogRecordProcessorBase {
+  constructor(_exporter, config) {
+    __publicField(this, "_exporter");
+    __publicField(this, "_maxExportBatchSize");
+    __publicField(this, "_maxQueueSize");
+    __publicField(this, "_scheduledDelayMillis");
+    __publicField(this, "_exportTimeoutMillis");
+    __publicField(this, "_finishedLogRecords", []);
+    __publicField(this, "_timer");
+    __publicField(this, "_shutdownOnce");
+    this._exporter = _exporter;
+    this._maxExportBatchSize = (config == null ? void 0 : config.maxExportBatchSize) ?? getNumberFromEnv() ?? 512;
+    this._maxQueueSize = (config == null ? void 0 : config.maxQueueSize) ?? getNumberFromEnv() ?? 2048;
+    this._scheduledDelayMillis = (config == null ? void 0 : config.scheduledDelayMillis) ?? getNumberFromEnv() ?? 5e3;
+    this._exportTimeoutMillis = (config == null ? void 0 : config.exportTimeoutMillis) ?? getNumberFromEnv() ?? 3e4;
+    this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+    if (this._maxExportBatchSize > this._maxQueueSize) {
+      diag.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((resolve, 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(() => {
+        resolve();
+      }).catch(reject);
+    });
+  }
+  _flushOneBatch() {
+    this._clearTimer();
+    if (this._finishedLogRecords.length === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      callWithTimeout(this._export(this._finishedLogRecords.splice(0, this._maxExportBatchSize)), this._exportTimeoutMillis).then(() => resolve()).catch(reject);
+    });
+  }
+  _maybeStartTimer() {
+    if (this._timer !== void 0) {
+      return;
+    }
+    this._timer = setTimeout(() => {
+      this._flushOneBatch().then(() => {
+        if (this._finishedLogRecords.length > 0) {
+          this._clearTimer();
+          this._maybeStartTimer();
+        }
+      }).catch((e) => {
+        globalErrorHandler(e);
+      });
+    }, this._scheduledDelayMillis);
+    unrefTimer(this._timer);
+  }
+  _clearTimer() {
+    if (this._timer !== void 0) {
+      clearTimeout(this._timer);
+      this._timer = void 0;
+    }
+  }
+  _export(logRecords) {
+    const doExport = () => internal._export(this._exporter, logRecords).then((result) => {
+      if (result.code !== ExportResultCode.SUCCESS) {
+        globalErrorHandler(result.error ?? new Error(`BatchLogRecordProcessor: log record export failed (status ${result})`));
+      }
+    }).catch(globalErrorHandler);
+    const pendingResources = logRecords.map((logRecord) => logRecord.resource).filter((resource) => resource.asyncAttributesPending);
+    if (pendingResources.length === 0) {
+      return doExport();
+    } else {
+      return Promise.all(pendingResources.map((resource) => {
+        var _a;
+        return (_a = resource.waitForAsyncAttributes) == null ? void 0 : _a.call(resource);
+      })).then(doExport, globalErrorHandler);
+    }
+  }
+}
+class BatchLogRecordProcessor extends BatchLogRecordProcessorBase {
+  constructor(exporter, config) {
+    super(exporter, config);
+    __publicField(this, "_visibilityChangeListener");
+    __publicField(this, "_pageHideListener");
+    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 == null ? void 0 : 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);
+  }
+}
+function initLibraryLoggerProvider(context2) {
+  const logExporter = new OTLPLogExporter({
+    url: context2.windowOriginUrl + "/api/v1/logs",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const resource = resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: "superblocks-ui-framework",
+    "user-id": context2.userId,
+    "user-email": context2.userEmail,
+    "organization-id": context2.orgId,
+    "organization-name": context2.orgName,
+    "application-id": context2.appId,
+    "deployment.environment": context2.environment
+  });
+  const loggerProvider = new LoggerProvider({
+    resource,
+    processors: [new BatchLogRecordProcessor(logExporter)]
+  });
+  const otelLogger = loggerProvider.getLogger(
+    "superblocks-ui-framework",
+    "1.0.0"
+  );
+  LibraryEarlyConsoleBuffer.getInstance().enableOpenTelemetry(otelLogger);
+}
+export {
+  initLibraryLoggerProvider
+};
+//# sourceMappingURL=logs-DWaPDDub.js.map