@inference-net/otel-cf-workers 2.0.0

package/dist/index.js

@@ -0,0 +1,3664 @@
+import { Buffer } from 'node:buffer';
+import { TraceFlags, SpanStatusCode, context, ROOT_CONTEXT, SpanKind, trace, propagation } from '@opentelemetry/api';
+import { TraceIdRatioBasedSampler, ParentBasedSampler, RandomIdGenerator, SamplingDecision } from '@opentelemetry/sdk-trace-base';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { ExportResultCode, sanitizeAttributes, isAttributeValue, isTimeInput, hrTimeDuration, W3CTraceContextPropagator } from '@opentelemetry/core';
+import { OTLPExporterError } from '@opentelemetry/otlp-exporter-base';
+import { JsonTraceSerializer } from '@opentelemetry/otlp-transformer';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { EventEmitter } from 'node:events';
+import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
+import { FAAS_TRIGGER_VALUE_PUBSUB, ATTR_FAAS_TRIGGER, FAAS_TRIGGER_VALUE_TIMER, ATTR_FAAS_TIME, ATTR_FAAS_CRON, ATTR_MESSAGING_DESTINATION_NAME, ATTR_RPC_MESSAGE_ID } from '@opentelemetry/semantic-conventions/incubating';
+import { DurableObject, env } from 'cloudflare:workers';
+
+globalThis.Buffer = Buffer;
+
+function multiTailSampler(samplers) {
+  return (traceInfo) => {
+    return samplers.reduce((result, sampler) => result || sampler(traceInfo), false);
+  };
+}
+const isHeadSampled = (traceInfo) => {
+  const localRootSpan = traceInfo.localRootSpan;
+  return (localRootSpan.spanContext().traceFlags & TraceFlags.SAMPLED) === TraceFlags.SAMPLED;
+};
+const isRootErrorSpan = (traceInfo) => {
+  const localRootSpan = traceInfo.localRootSpan;
+  return localRootSpan.status.code === SpanStatusCode.ERROR;
+};
+function createSampler(conf) {
+  const ratioSampler = new TraceIdRatioBasedSampler(conf.ratio);
+  if (typeof conf.acceptRemote === "boolean" && !conf.acceptRemote) {
+    return new ParentBasedSampler({
+      root: ratioSampler,
+      remoteParentSampled: ratioSampler,
+      remoteParentNotSampled: ratioSampler
+    });
+  } else {
+    return new ParentBasedSampler({ root: ratioSampler });
+  }
+}
+
+function isSpanProcessorConfig(config) {
+  return !!config.spanProcessors;
+}
+
+const unwrapSymbol = Symbol("unwrap");
+function isWrapped(item) {
+  return item && !!item[unwrapSymbol];
+}
+function isProxyable(item) {
+  return item !== null && typeof item === "object" || typeof item === "function";
+}
+function wrap(item, handler, autoPassthrough = true) {
+  if (isWrapped(item) || !isProxyable(item)) {
+    return item;
+  }
+  const proxyHandler = Object.assign({}, handler);
+  proxyHandler.get = (target, prop, receiver) => {
+    if (prop === unwrapSymbol) {
+      return item;
+    } else {
+      if (handler.get) {
+        return handler.get(target, prop, receiver);
+      } else if (prop === "bind") {
+        return () => receiver;
+      } else if (autoPassthrough) {
+        return passthroughGet(target, prop);
+      }
+    }
+  };
+  proxyHandler.apply = (target, thisArg, argArray) => {
+    if (handler.apply) {
+      return handler.apply(unwrap(target), unwrap(thisArg), argArray);
+    }
+  };
+  return new Proxy(item, proxyHandler);
+}
+function unwrap(item) {
+  if (item && isWrapped(item)) {
+    return item[unwrapSymbol];
+  } else {
+    return item;
+  }
+}
+function passthroughGet(target, prop, thisArg) {
+  const unwrappedTarget = unwrap(target);
+  thisArg = unwrap(thisArg) || unwrappedTarget;
+  const value = Reflect.get(unwrappedTarget, prop);
+  if (typeof value === "function") {
+    if (value.constructor.name === "RpcProperty") {
+      return (...args) => unwrappedTarget[prop](...args);
+    }
+    return value.bind(thisArg);
+  } else {
+    return value;
+  }
+}
+
+const PACKAGE_VERSION = "2.0.0";
+const PACKAGE_NAME = "@inference-net/otel-cf-workers";
+const ATTR_CLOUDFLARE_COLO = "cloudflare.colo";
+const ATTR_CLOUDFLARE_RAY_ID = "cloudflare.ray_id";
+const ATTR_CLOUDFLARE_HANDLER_TYPE = "cloudflare.handler_type";
+const ATTR_CLOUDFLARE_EXECUTION_MODEL = "cloudflare.execution_model";
+const ATTR_CLOUDFLARE_VERIFIED_BOT_CATEGORY = "cloudflare.verified_bot_category";
+const ATTR_CLOUDFLARE_ASN = "cloudflare.asn";
+const ATTR_GEO_TIMEZONE = "geo.timezone";
+const ATTR_GEO_CONTINENT_CODE = "geo.continent.code";
+const ATTR_GEO_COUNTRY_CODE = "geo.country.code";
+const ATTR_GEO_LOCALITY_NAME = "geo.locality.name";
+const ATTR_GEO_LOCALITY_REGION = "geo.locality.region";
+const ATTR_USER_AGENT_OS_NAME = "user_agent.os.name";
+const ATTR_USER_AGENT_OS_VERSION = "user_agent.os.version";
+const ATTR_USER_AGENT_BROWSER_NAME = "user_agent.browser.name";
+const ATTR_USER_AGENT_BROWSER_MAJOR_VERSION = "user_agent.browser.major_version";
+const ATTR_USER_AGENT_BROWSER_VERSION = "user_agent.browser.version";
+const ATTR_USER_AGENT_ENGINE_NAME = "user_agent.engine.name";
+const ATTR_USER_AGENT_ENGINE_VERSION = "user_agent.engine.version";
+const ATTR_USER_AGENT_DEVICE_TYPE = "user_agent.device.type";
+const ATTR_USER_AGENT_DEVICE_VENDOR = "user_agent.device.vendor";
+const ATTR_USER_AGENT_DEVICE_MODEL = "user_agent.device.model";
+const ATTR_HTTP_REQUEST_HEADER_CONTENT_TYPE = "http.request.header.content-type";
+const ATTR_HTTP_REQUEST_HEADER_CONTENT_LENGTH = "http.request.header.content-length";
+const ATTR_HTTP_REQUEST_HEADER_ACCEPT = "http.request.header.accept";
+const ATTR_HTTP_REQUEST_HEADER_ACCEPT_ENCODING = "http.request.header.accept-encoding";
+const ATTR_HTTP_REQUEST_HEADER_ACCEPT_LANGUAGE = "http.request.header.accept-language";
+const ATTR_CLOUDFLARE_SCHEDULED_TIME = "cloudflare.scheduled_time";
+const ATTR_CLOUDFLARE_QUEUE_NAME = "cloudflare.queue.name";
+const ATTR_CLOUDFLARE_QUEUE_BATCH_SIZE = "cloudflare.queue.batch_size";
+const ATTR_CLOUDFLARE_EMAIL_FROM = "cloudflare.email.from";
+const ATTR_CLOUDFLARE_EMAIL_TO = "cloudflare.email.to";
+const ATTR_CLOUDFLARE_EMAIL_SIZE = "cloudflare.email.size";
+const ATTR_CLOUDFLARE_BINDING_TYPE = "cloudflare.binding.type";
+const ATTR_CLOUDFLARE_BINDING_NAME = "cloudflare.binding.name";
+const ATTR_DB_SYSTEM_NAME = "db.system.name";
+const ATTR_DB_OPERATION_NAME = "db.operation.name";
+const ATTR_DB_QUERY_TEXT = "db.query.text";
+const ATTR_DB_OPERATION_BATCH_SIZE = "db.operation.batch.size";
+const ATTR_CLOUDFLARE_D1_RESPONSE_SIZE_AFTER = "cloudflare.d1.response.size_after";
+const ATTR_CLOUDFLARE_D1_RESPONSE_ROWS_READ = "cloudflare.d1.response.rows_read";
+const ATTR_CLOUDFLARE_D1_RESPONSE_ROWS_WRITTEN = "cloudflare.d1.response.rows_written";
+const ATTR_CLOUDFLARE_D1_RESPONSE_LAST_ROW_ID = "cloudflare.d1.response.last_row_id";
+const ATTR_CLOUDFLARE_D1_RESPONSE_CHANGED_DB = "cloudflare.d1.response.changed_db";
+const ATTR_CLOUDFLARE_D1_RESPONSE_CHANGES = "cloudflare.d1.response.changes";
+const ATTR_CLOUDFLARE_D1_RESPONSE_SQL_DURATION_MS = "cloudflare.d1.response.sql_duration_ms";
+const ATTR_CLOUDFLARE_KV_QUERY_KEYS = "cloudflare.kv.query.keys";
+const ATTR_CLOUDFLARE_KV_QUERY_KEYS_COUNT = "cloudflare.kv.query.keys.count";
+const ATTR_CLOUDFLARE_KV_QUERY_TYPE = "cloudflare.kv.query.type";
+const ATTR_CLOUDFLARE_KV_QUERY_CACHE_TTL = "cloudflare.kv.query.cache_ttl";
+const ATTR_CLOUDFLARE_KV_QUERY_VALUE_TYPE = "cloudflare.kv.query.value_type";
+const ATTR_CLOUDFLARE_KV_QUERY_EXPIRATION = "cloudflare.kv.query.expiration";
+const ATTR_CLOUDFLARE_KV_QUERY_EXPIRATION_TTL = "cloudflare.kv.query.expiration_ttl";
+const ATTR_CLOUDFLARE_KV_QUERY_METADATA = "cloudflare.kv.query.metadata";
+const ATTR_CLOUDFLARE_KV_QUERY_PREFIX = "cloudflare.kv.query.prefix";
+const ATTR_CLOUDFLARE_KV_QUERY_LIMIT = "cloudflare.kv.query.limit";
+const ATTR_CLOUDFLARE_KV_QUERY_CURSOR = "cloudflare.kv.query.cursor";
+const ATTR_CLOUDFLARE_KV_RESPONSE_METADATA = "cloudflare.kv.response.metadata";
+const ATTR_CLOUDFLARE_KV_RESPONSE_CACHE_STATUS = "cloudflare.kv.response.cache_status";
+const ATTR_CLOUDFLARE_KV_RESPONSE_LIST_COMPLETE = "cloudflare.kv.response.list_complete";
+const ATTR_CLOUDFLARE_KV_RESPONSE_CURSOR = "cloudflare.kv.response.cursor";
+const ATTR_CLOUDFLARE_R2_QUERY_KEY = "cloudflare.r2.query.key";
+const ATTR_CLOUDFLARE_R2_QUERY_PREFIX = "cloudflare.r2.query.prefix";
+const ATTR_CLOUDFLARE_R2_QUERY_LIMIT = "cloudflare.r2.query.limit";
+const ATTR_CLOUDFLARE_R2_QUERY_DELIMITER = "cloudflare.r2.query.delimiter";
+const ATTR_CLOUDFLARE_R2_QUERY_START_AFTER = "cloudflare.r2.query.start_after";
+const ATTR_CLOUDFLARE_R2_QUERY_INCLUDE = "cloudflare.r2.query.include";
+const ATTR_CLOUDFLARE_R2_QUERY_OFFSET = "cloudflare.r2.query.offset";
+const ATTR_CLOUDFLARE_R2_QUERY_LENGTH = "cloudflare.r2.query.length";
+const ATTR_CLOUDFLARE_R2_QUERY_SUFFIX = "cloudflare.r2.query.suffix";
+const ATTR_CLOUDFLARE_R2_QUERY_ONLY_IF = "cloudflare.r2.query.only_if";
+const ATTR_CLOUDFLARE_R2_PUT_HTTP_METADATA = "cloudflare.r2.put.http_metadata";
+const ATTR_CLOUDFLARE_R2_PUT_CUSTOM_METADATA = "cloudflare.r2.put.custom_metadata";
+const ATTR_CLOUDFLARE_R2_PUT_MD5 = "cloudflare.r2.put.md5";
+const ATTR_CLOUDFLARE_R2_PUT_SHA1 = "cloudflare.r2.put.sha1";
+const ATTR_CLOUDFLARE_R2_PUT_SHA256 = "cloudflare.r2.put.sha256";
+const ATTR_CLOUDFLARE_R2_PUT_SHA384 = "cloudflare.r2.put.sha384";
+const ATTR_CLOUDFLARE_R2_PUT_SHA512 = "cloudflare.r2.put.sha512";
+const ATTR_CLOUDFLARE_R2_PUT_STORAGE_CLASS = "cloudflare.r2.put.storage_class";
+const ATTR_CLOUDFLARE_R2_RESPONSE_SIZE = "cloudflare.r2.response.size";
+const ATTR_CLOUDFLARE_R2_RESPONSE_ETAG = "cloudflare.r2.response.etag";
+const ATTR_CLOUDFLARE_R2_RESPONSE_VERSION = "cloudflare.r2.response.version";
+const ATTR_CLOUDFLARE_R2_RESPONSE_UPLOADED = "cloudflare.r2.response.uploaded";
+const ATTR_CLOUDFLARE_R2_RESPONSE_HTTP_METADATA_CONTENT_TYPE = "cloudflare.r2.response.http_metadata.content_type";
+const ATTR_CLOUDFLARE_R2_RESPONSE_HTTP_METADATA_CONTENT_LANGUAGE = "cloudflare.r2.response.http_metadata.content_language";
+const ATTR_CLOUDFLARE_R2_RESPONSE_HTTP_METADATA_CONTENT_DISPOSITION = "cloudflare.r2.response.http_metadata.content_disposition";
+const ATTR_CLOUDFLARE_R2_RESPONSE_HTTP_METADATA_CONTENT_ENCODING = "cloudflare.r2.response.http_metadata.content_encoding";
+const ATTR_CLOUDFLARE_R2_RESPONSE_HTTP_METADATA_CACHE_CONTROL = "cloudflare.r2.response.http_metadata.cache_control";
+const ATTR_CLOUDFLARE_R2_RESPONSE_HTTP_METADATA_CACHE_EXPIRY = "cloudflare.r2.response.http_metadata.cache_expiry";
+const ATTR_CLOUDFLARE_R2_RESPONSE_CUSTOM_METADATA_KEYS = "cloudflare.r2.response.custom_metadata.keys";
+const ATTR_CLOUDFLARE_R2_RESPONSE_RANGE = "cloudflare.r2.response.range";
+const ATTR_CLOUDFLARE_R2_RESPONSE_STORAGE_CLASS = "cloudflare.r2.response.storage_class";
+const ATTR_CLOUDFLARE_R2_RESPONSE_CHECKSUMS_MD5 = "cloudflare.r2.response.checksums.md5";
+const ATTR_CLOUDFLARE_R2_RESPONSE_CHECKSUMS_SHA1 = "cloudflare.r2.response.checksums.sha1";
+const ATTR_CLOUDFLARE_R2_RESPONSE_CHECKSUMS_SHA256 = "cloudflare.r2.response.checksums.sha256";
+const ATTR_CLOUDFLARE_R2_RESPONSE_CHECKSUMS_SHA384 = "cloudflare.r2.response.checksums.sha384";
+const ATTR_CLOUDFLARE_R2_RESPONSE_CHECKSUMS_SHA512 = "cloudflare.r2.response.checksums.sha512";
+const ATTR_CLOUDFLARE_R2_LIST_TRUNCATED = "cloudflare.r2.list.truncated";
+const ATTR_CLOUDFLARE_R2_LIST_OBJECTS_COUNT = "cloudflare.r2.list.objects.count";
+const ATTR_CLOUDFLARE_R2_LIST_DELIMITED_PREFIXES_COUNT = "cloudflare.r2.list.delimited_prefixes.count";
+const ATTR_CLOUDFLARE_R2_LIST_CURSOR = "cloudflare.r2.list.cursor";
+const ATTR_CLOUDFLARE_R2_MULTIPART_UPLOAD_ID = "cloudflare.r2.multipart.upload_id";
+const ATTR_CLOUDFLARE_DO_KV_QUERY_KEYS = "cloudflare.durable_object.kv.query.keys";
+const ATTR_CLOUDFLARE_DO_KV_QUERY_KEYS_COUNT = "cloudflare.durable_object.kv.query.keys.count";
+const ATTR_CLOUDFLARE_DO_KV_QUERY_START = "cloudflare.durable_object.kv.query.start";
+const ATTR_CLOUDFLARE_DO_KV_QUERY_START_AFTER = "cloudflare.durable_object.kv.query.startAfter";
+const ATTR_CLOUDFLARE_DO_KV_QUERY_END = "cloudflare.durable_object.kv.query.end";
+const ATTR_CLOUDFLARE_DO_KV_QUERY_PREFIX = "cloudflare.durable_object.kv.query.prefix";
+const ATTR_CLOUDFLARE_DO_KV_QUERY_REVERSE = "cloudflare.durable_object.kv.query.reverse";
+const ATTR_CLOUDFLARE_DO_KV_QUERY_LIMIT = "cloudflare.durable_object.kv.query.limit";
+const ATTR_CLOUDFLARE_DO_KV_RESPONSE_DELETED_COUNT = "cloudflare.durable_object.kv.response.deleted_count";
+const ATTR_CLOUDFLARE_DO_ALLOW_CONCURRENCY = "cloudflare.durable_object.allow_concurrency";
+const ATTR_CLOUDFLARE_DO_ALLOW_UNCONFIRMED = "cloudflare.durable_object.allow_unconfirmed";
+const ATTR_CLOUDFLARE_DO_NO_CACHE = "cloudflare.durable_object.no_cache";
+const ATTR_CLOUDFLARE_DO_SQL_QUERY_BINDINGS = "cloudflare.durable_object.query.bindings";
+const ATTR_CLOUDFLARE_DO_SQL_RESPONSE_ROWS_READ = "cloudflare.durable_object.response.rows_read";
+const ATTR_CLOUDFLARE_DO_SQL_RESPONSE_ROWS_WRITTEN = "cloudflare.durable_object.response.rows_written";
+const ATTR_CLOUDFLARE_IMAGES_KEY = "cloudflare.images.key";
+const ATTR_CLOUDFLARE_IMAGES_VARIANTS_COUNT = "cloudflare.images.variants.count";
+const ATTR_CLOUDFLARE_IMAGES_UPLOADED = "cloudflare.images.uploaded";
+const ATTR_CLOUDFLARE_IMAGES_RESPONSE_ID = "cloudflare.images.response.id";
+const ATTR_CLOUDFLARE_IMAGES_RESPONSE_FILENAME = "cloudflare.images.response.filename";
+const ATTR_CLOUDFLARE_IMAGES_METADATA_KEYS = "cloudflare.images.metadata.keys";
+const ATTR_CLOUDFLARE_IMAGES_REQUIRE_SIGNED_URLS = "cloudflare.images.require_signed_urls";
+const ATTR_CLOUDFLARE_RATE_LIMIT_KEY = "cloudflare.rate_limit.key";
+const ATTR_CLOUDFLARE_RATE_LIMIT_ALLOWED = "cloudflare.rate_limit.allowed";
+const ATTR_CLOUDFLARE_RATE_LIMIT_SUCCESS = "cloudflare.rate_limit.success";
+const DEFAULT_OTLP_HEADERS = {
+  accept: "application/json",
+  "content-type": "application/json",
+  "user-agent": `Cloudflare Worker ${PACKAGE_NAME} v${PACKAGE_VERSION}`
+};
+const SEVERITY_NUMBERS = {
+  TRACE: 1,
+  TRACE2: 2,
+  TRACE3: 3,
+  TRACE4: 4,
+  DEBUG: 5,
+  DEBUG2: 6,
+  DEBUG3: 7,
+  DEBUG4: 8,
+  INFO: 9,
+  INFO2: 10,
+  INFO3: 11,
+  INFO4: 12,
+  WARN: 13,
+  WARN2: 14,
+  WARN3: 15,
+  WARN4: 16,
+  ERROR: 17,
+  ERROR2: 18,
+  ERROR3: 19,
+  ERROR4: 20,
+  FATAL: 21,
+  FATAL2: 22,
+  FATAL3: 23,
+  FATAL4: 24
+};
+
+class OTLPExporter {
+  headers;
+  url;
+  constructor(config) {
+    this.url = config.url;
+    this.headers = Object.assign({}, DEFAULT_OTLP_HEADERS, config.headers);
+  }
+  export(items, resultCallback) {
+    this._export(items).then(() => {
+      resultCallback({ code: ExportResultCode.SUCCESS });
+    }).catch((error) => {
+      resultCallback({ code: ExportResultCode.FAILED, error });
+    });
+  }
+  _export(items) {
+    return new Promise((resolve, reject) => {
+      try {
+        this.send(items, resolve, reject);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+  send(items, onSuccess, onError) {
+    const decoder = new TextDecoder();
+    const exportMessage = JsonTraceSerializer.serializeRequest(items);
+    const body = decoder.decode(exportMessage);
+    const params = {
+      method: "POST",
+      headers: this.headers,
+      body
+    };
+    unwrap(fetch)(this.url, params).then((response) => {
+      if (response.ok) {
+        onSuccess();
+      } else {
+        onError(new OTLPExporterError(`Exporter received a statusCode: ${response.status}`));
+      }
+    }).catch((error) => {
+      onError(new OTLPExporterError(`Exception during export: ${error.toString()}`, error.code, error.stack));
+    });
+  }
+  async shutdown() {
+  }
+}
+
+function getSampler() {
+  const conf = getActiveConfig();
+  if (!conf) {
+    console.log("Could not find config for sampling, sending everything by default");
+  }
+  return conf ? conf.sampling.tailSampler : () => true;
+}
+class TraceState {
+  unexportedSpans = [];
+  inprogressSpans = /* @__PURE__ */ new Set();
+  exporter;
+  exportPromises = [];
+  localRootSpan;
+  traceDecision;
+  constructor(exporter) {
+    this.exporter = exporter;
+  }
+  addSpan(span) {
+    const readableSpan = span;
+    this.localRootSpan = this.localRootSpan || readableSpan;
+    this.unexportedSpans.push(readableSpan);
+    this.inprogressSpans.add(span.spanContext().spanId);
+  }
+  endSpan(span) {
+    this.inprogressSpans.delete(span.spanContext().spanId);
+    if (this.inprogressSpans.size === 0) {
+      this.flush();
+    }
+  }
+  sample() {
+    if (this.traceDecision === void 0 && this.unexportedSpans.length > 0) {
+      const sampler = getSampler();
+      this.traceDecision = sampler({
+        traceId: this.localRootSpan.spanContext().traceId,
+        localRootSpan: this.localRootSpan,
+        spans: this.unexportedSpans
+      });
+    }
+    this.unexportedSpans = this.traceDecision ? this.unexportedSpans : [];
+  }
+  async flush() {
+    if (this.unexportedSpans.length > 0) {
+      const unfinishedSpans = this.unexportedSpans.filter((span) => this.isSpanInProgress(span));
+      for (const span of unfinishedSpans) {
+        console.log(`Span ${span.spanContext().spanId} was not ended properly`);
+        span.end();
+      }
+      this.sample();
+      this.exportPromises.push(this.exportSpans(this.unexportedSpans));
+      this.unexportedSpans = [];
+    }
+    if (this.exportPromises.length > 0) {
+      await Promise.allSettled(this.exportPromises);
+    }
+  }
+  isSpanInProgress(span) {
+    return this.inprogressSpans.has(span.spanContext().spanId);
+  }
+  async exportSpans(spans) {
+    await scheduler.wait(1);
+    const promise = new Promise((resolve, reject) => {
+      this.exporter.export(spans, (result) => {
+        if (result.code === ExportResultCode.SUCCESS) {
+          resolve();
+        } else {
+          console.log("exporting spans failed! " + result.error);
+          reject(result.error);
+        }
+      });
+    });
+    await promise;
+  }
+}
+class BatchTraceSpanProcessor {
+  constructor(exporter) {
+    this.exporter = exporter;
+  }
+  traces = {};
+  getTraceState(traceId) {
+    const traceState = this.traces[traceId] || new TraceState(this.exporter);
+    this.traces[traceId] = traceState;
+    return traceState;
+  }
+  onStart(span, _parentContext) {
+    const traceId = span.spanContext().traceId;
+    this.getTraceState(traceId).addSpan(span);
+  }
+  onEnd(span) {
+    const traceId = span.spanContext().traceId;
+    this.getTraceState(traceId).endSpan(span);
+  }
+  async forceFlush(traceId) {
+    if (traceId) {
+      await this.getTraceState(traceId).flush();
+    } else {
+      const promises = Object.values(this.traces).map((traceState) => traceState.flush);
+      await Promise.allSettled(promises);
+    }
+  }
+  async shutdown() {
+    await this.forceFlush();
+  }
+}
+
+class ImmediateLogRecordProcessor {
+  transport;
+  exportPromises = [];
+  constructor(transport) {
+    this.transport = transport;
+  }
+  onEmit(logRecord, _context) {
+    this.exportPromises.push(this.exportLog(logRecord));
+  }
+  async exportLog(logRecord) {
+    await scheduler.wait(1);
+    return new Promise((resolve, reject) => {
+      this.transport.export([logRecord], (result) => {
+        if (result.code === ExportResultCode.SUCCESS) {
+          resolve();
+        } else {
+          console.error("Failed to export log:", result.error);
+          reject(result.error);
+        }
+      });
+    });
+  }
+  async forceFlush() {
+    if (this.exportPromises.length > 0) {
+      await Promise.allSettled(this.exportPromises);
+      this.exportPromises = [];
+    }
+  }
+  async shutdown() {
+    await this.forceFlush();
+    await this.transport.shutdown();
+  }
+}
+class BatchSizeLogRecordProcessor {
+  transport;
+  logRecords = [];
+  exportPromises = [];
+  maxQueueSize;
+  maxExportBatchSize;
+  constructor(transport, config) {
+    this.transport = transport;
+    this.maxQueueSize = config?.maxQueueSize ?? 512;
+    this.maxExportBatchSize = config?.maxExportBatchSize ?? this.maxQueueSize;
+  }
+  onEmit(logRecord, _context) {
+    this.logRecords.push(logRecord);
+    if (this.logRecords.length >= this.maxQueueSize) {
+      this.exportPromises.push(this.export());
+    }
+  }
+  async forceFlush() {
+    if (this.logRecords.length > 0) {
+      this.exportPromises.push(this.export());
+    }
+    if (this.exportPromises.length > 0) {
+      await Promise.allSettled(this.exportPromises);
+      this.exportPromises = [];
+    }
+  }
+  async export() {
+    const batch = this.logRecords.splice(0, this.maxExportBatchSize);
+    if (batch.length === 0) {
+      return;
+    }
+    await scheduler.wait(1);
+    return new Promise((resolve, reject) => {
+      this.transport.export(batch, (result) => {
+        if (result.code === ExportResultCode.SUCCESS) {
+          resolve();
+        } else {
+          console.error("Failed to export logs:", result.error);
+          reject(result.error);
+        }
+      });
+    });
+  }
+  async shutdown() {
+    await this.forceFlush();
+    await this.transport.shutdown();
+  }
+}
+class MultiTransportLogRecordProcessor {
+  processors;
+  constructor(transports, config) {
+    this.processors = transports.map((transport) => {
+      return createLogProcessor(transport, config);
+    });
+  }
+  onEmit(logRecord, context) {
+    this.processors.forEach((p) => p.onEmit(logRecord, context));
+  }
+  async forceFlush() {
+    await Promise.allSettled(this.processors.map((p) => p.forceFlush()));
+  }
+  async shutdown() {
+    await Promise.allSettled(this.processors.map((p) => p.shutdown()));
+  }
+}
+function createLogProcessor(transport, config) {
+  const strategy = config?.strategy ?? "size";
+  switch (strategy) {
+    case "immediate":
+      return new ImmediateLogRecordProcessor(transport);
+    case "size":
+      return new BatchSizeLogRecordProcessor(transport, config);
+    default:
+      throw new Error(`Unknown batch strategy: ${strategy}`);
+  }
+}
+
+const traceConfigSymbol = Symbol("Otel Workers Tracing Configuration");
+const logsConfigSymbol = Symbol("Otel Workers Logs Configuration");
+function setConfig(config, ctx = context.active()) {
+  let newCtx = ctx;
+  if (config.trace) {
+    newCtx = newCtx.setValue(traceConfigSymbol, config.trace);
+  }
+  if (config.logs) {
+    newCtx = newCtx.setValue(logsConfigSymbol, config.logs);
+  }
+  return newCtx;
+}
+function getActiveConfig() {
+  const config = context.active().getValue(traceConfigSymbol);
+  return config || void 0;
+}
+function isSpanExporter(exporterConfig) {
+  return !!exporterConfig.export;
+}
+function isSampler(sampler) {
+  return !!sampler.shouldSample;
+}
+function parseConfig(supplied) {
+  const config = {};
+  if (supplied.trace) {
+    config.trace = parseTraceConfig(supplied.trace, supplied.propagator);
+  }
+  if (supplied.logs) {
+    config.logs = parseLogsConfig(supplied.logs);
+  }
+  return config;
+}
+function parseTraceConfig(supplied, propagator) {
+  if (isSpanProcessorConfig(supplied)) {
+    const headSampleConf = supplied.sampling?.headSampler || { ratio: 1 };
+    const headSampler = isSampler(headSampleConf) ? headSampleConf : createSampler(headSampleConf);
+    const spanProcessors = Array.isArray(supplied.spanProcessors) ? supplied.spanProcessors : [supplied.spanProcessors];
+    if (spanProcessors.length === 0) {
+      console.log(
+        "Warning! You must either specify an exporter or your own SpanProcessor(s)/Exporter combination in the open-telemetry configuration."
+      );
+    }
+    return {
+      fetch: {
+        includeTraceContext: supplied.fetch?.includeTraceContext ?? true
+      },
+      handlers: {
+        fetch: {
+          acceptTraceContext: supplied.handlers?.fetch?.acceptTraceContext ?? true
+        }
+      },
+      postProcessor: supplied.postProcessor || ((spans) => spans),
+      sampling: {
+        headSampler,
+        tailSampler: supplied.sampling?.tailSampler || multiTailSampler([isHeadSampled, isRootErrorSpan])
+      },
+      spanProcessors,
+      instrumentation: {
+        instrumentGlobalCache: supplied.instrumentation?.instrumentGlobalCache ?? true,
+        instrumentGlobalFetch: supplied.instrumentation?.instrumentGlobalFetch ?? true
+      },
+      batching: {
+        strategy: supplied.batching?.strategy ?? "trace",
+        maxQueueSize: supplied.batching?.maxQueueSize,
+        maxExportBatchSize: supplied.batching?.maxExportBatchSize
+      }
+    };
+  } else {
+    const exporter = isSpanExporter(supplied.exporter) ? supplied.exporter : new OTLPExporter(supplied.exporter);
+    const spanProcessors = [new BatchTraceSpanProcessor(exporter)];
+    const newConfig = Object.assign({}, supplied, { exporter: void 0, spanProcessors });
+    return parseTraceConfig(newConfig);
+  }
+}
+function parseLogsConfig(supplied) {
+  const processors = supplied.transports && supplied.transports.length > 0 ? [new MultiTransportLogRecordProcessor(supplied.transports, supplied.batching)] : [];
+  return {
+    processors,
+    instrumentation: {
+      instrumentConsole: supplied.instrumentation?.instrumentConsole ?? false
+    }
+  };
+}
+
+const ADD_LISTENER_METHODS = [
+  "addListener",
+  "on",
+  "once",
+  "prependListener",
+  "prependOnceListener"
+];
+class AbstractAsyncHooksContextManager {
+  /**
+   * Binds a the certain context or the active one to the target function and then returns the target
+   * @param context A context (span) to be bind to target
+   * @param target a function or event emitter. When target or one of its callbacks is called,
+   *  the provided context will be used as the active context for the duration of the call.
+   */
+  bind(context, target) {
+    if (target instanceof EventEmitter) {
+      return this._bindEventEmitter(context, target);
+    }
+    if (typeof target === "function") {
+      return this._bindFunction(context, target);
+    }
+    return target;
+  }
+  _bindFunction(context, target) {
+    const manager = this;
+    const contextWrapper = function(...args) {
+      return manager.with(context, () => target.apply(this, args));
+    };
+    Object.defineProperty(contextWrapper, "length", {
+      enumerable: false,
+      configurable: true,
+      writable: false,
+      value: target.length
+    });
+    return contextWrapper;
+  }
+  /**
+   * By default, EventEmitter call their callback with their context, which we do
+   * not want, instead we will bind a specific context to all callbacks that
+   * go through it.
+   * @param context the context we want to bind
+   * @param ee EventEmitter an instance of EventEmitter to patch
+   */
+  _bindEventEmitter(context, ee) {
+    const map = this._getPatchMap(ee);
+    if (map !== void 0) return ee;
+    this._createPatchMap(ee);
+    ADD_LISTENER_METHODS.forEach((methodName) => {
+      if (ee[methodName] === void 0) return;
+      ee[methodName] = this._patchAddListener(ee, ee[methodName], context);
+    });
+    if (typeof ee.removeListener === "function") {
+      ee.removeListener = this._patchRemoveListener(ee, ee.removeListener);
+    }
+    if (typeof ee.off === "function") {
+      ee.off = this._patchRemoveListener(ee, ee.off);
+    }
+    if (typeof ee.removeAllListeners === "function") {
+      ee.removeAllListeners = this._patchRemoveAllListeners(ee, ee.removeAllListeners);
+    }
+    return ee;
+  }
+  /**
+   * Patch methods that remove a given listener so that we match the "patched"
+   * version of that listener (the one that propagate context).
+   * @param ee EventEmitter instance
+   * @param original reference to the patched method
+   */
+  _patchRemoveListener(ee, original) {
+    const contextManager = this;
+    return function(event, listener) {
+      const events = contextManager._getPatchMap(ee)?.[event];
+      if (events === void 0) {
+        return original.call(this, event, listener);
+      }
+      const patchedListener = events.get(listener);
+      return original.call(this, event, patchedListener || listener);
+    };
+  }
+  /**
+   * Patch methods that remove all listeners so we remove our
+   * internal references for a given event.
+   * @param ee EventEmitter instance
+   * @param original reference to the patched method
+   */
+  _patchRemoveAllListeners(ee, original) {
+    const contextManager = this;
+    return function(event) {
+      const map = contextManager._getPatchMap(ee);
+      if (map !== void 0) {
+        if (arguments.length === 0) {
+          contextManager._createPatchMap(ee);
+        } else if (map[event] !== void 0) {
+          delete map[event];
+        }
+      }
+      return original.apply(this, arguments);
+    };
+  }
+  /**
+   * Patch methods on an event emitter instance that can add listeners so we
+   * can force them to propagate a given context.
+   * @param ee EventEmitter instance
+   * @param original reference to the patched method
+   * @param [context] context to propagate when calling listeners
+   */
+  _patchAddListener(ee, original, context) {
+    const contextManager = this;
+    return function(event, listener) {
+      if (contextManager._wrapped) {
+        return original.call(this, event, listener);
+      }
+      let map = contextManager._getPatchMap(ee);
+      if (map === void 0) {
+        map = contextManager._createPatchMap(ee);
+      }
+      let listeners = map[event];
+      if (listeners === void 0) {
+        listeners = /* @__PURE__ */ new WeakMap();
+        map[event] = listeners;
+      }
+      const patchedListener = contextManager.bind(context, listener);
+      listeners.set(listener, patchedListener);
+      contextManager._wrapped = true;
+      try {
+        return original.call(this, event, patchedListener);
+      } finally {
+        contextManager._wrapped = false;
+      }
+    };
+  }
+  _createPatchMap(ee) {
+    const map = /* @__PURE__ */ Object.create(null);
+    ee[this._kOtListeners] = map;
+    return map;
+  }
+  _getPatchMap(ee) {
+    return ee[this._kOtListeners];
+  }
+  _kOtListeners = Symbol("OtListeners");
+  _wrapped = false;
+}
+class AsyncLocalStorageContextManager extends AbstractAsyncHooksContextManager {
+  _asyncLocalStorage;
+  constructor() {
+    super();
+    this._asyncLocalStorage = new AsyncLocalStorage();
+  }
+  active() {
+    return this._asyncLocalStorage.getStore() ?? ROOT_CONTEXT;
+  }
+  with(context, fn, thisArg, ...args) {
+    const cb = thisArg == null ? fn : fn.bind(thisArg);
+    return this._asyncLocalStorage.run(context, cb, ...args);
+  }
+  enable() {
+    return this;
+  }
+  disable() {
+    this._asyncLocalStorage.disable();
+    return this;
+  }
+}
+
+function transformExceptionAttributes(exception) {
+  const attributes = {};
+  if (typeof exception === "string") {
+    attributes[SemanticAttributes.EXCEPTION_MESSAGE] = exception;
+  } else {
+    if (exception.code) {
+      attributes[SemanticAttributes.EXCEPTION_TYPE] = exception.code.toString();
+    } else if (exception.name) {
+      attributes[SemanticAttributes.EXCEPTION_TYPE] = exception.name;
+    }
+    if (exception.message) {
+      attributes[SemanticAttributes.EXCEPTION_MESSAGE] = exception.message;
+    }
+    if (exception.stack) {
+      attributes[SemanticAttributes.EXCEPTION_STACKTRACE] = exception.stack;
+    }
+  }
+  return attributes;
+}
+function millisToHr$1(millis) {
+  return [Math.trunc(millis / 1e3), millis % 1e3 * 1e6];
+}
+function getHrTime$1(input) {
+  const now = Date.now();
+  if (!input) {
+    return millisToHr$1(now);
+  } else if (input instanceof Date) {
+    return millisToHr$1(input.getTime());
+  } else if (typeof input === "number") {
+    return millisToHr$1(input);
+  } else if (Array.isArray(input)) {
+    return input;
+  }
+  const v = input;
+  throw new Error(`unreachable value: ${JSON.stringify(v)}`);
+}
+function isAttributeKey(key) {
+  return typeof key === "string" && key.length > 0;
+}
+class SpanImpl {
+  name;
+  _spanContext;
+  onEnd;
+  parentSpanId;
+  parentSpanContext;
+  kind;
+  attributes;
+  status = {
+    code: SpanStatusCode.UNSET
+  };
+  endTime = [0, 0];
+  _duration = [0, 0];
+  startTime;
+  events = [];
+  links;
+  resource;
+  instrumentationScope = { name: "@inference-net/otel-cf-workers" };
+  _ended = false;
+  _droppedAttributesCount = 0;
+  _droppedEventsCount = 0;
+  _droppedLinksCount = 0;
+  constructor(init) {
+    this.name = init.name;
+    this._spanContext = init.spanContext;
+    this.parentSpanId = init.parentSpanId;
+    this.parentSpanContext = init.parentSpanContext;
+    this.kind = init.spanKind || SpanKind.INTERNAL;
+    this.attributes = sanitizeAttributes(init.attributes);
+    this.startTime = getHrTime$1(init.startTime);
+    this.links = init.links || [];
+    this.resource = init.resource;
+    this.onEnd = init.onEnd;
+  }
+  addLink(link) {
+    this.links.push(link);
+    return this;
+  }
+  addLinks(links) {
+    this.links.push(...links);
+    return this;
+  }
+  spanContext() {
+    return this._spanContext;
+  }
+  setAttribute(key, value) {
+    if (isAttributeKey(key) && isAttributeValue(value)) {
+      this.attributes[key] = value;
+    }
+    return this;
+  }
+  setAttributes(attributes) {
+    for (const [key, value] of Object.entries(attributes)) {
+      this.setAttribute(key, value);
+    }
+    return this;
+  }
+  addEvent(name, attributesOrStartTime, startTime) {
+    if (isTimeInput(attributesOrStartTime)) {
+      startTime = attributesOrStartTime;
+      attributesOrStartTime = void 0;
+    }
+    const attributes = sanitizeAttributes(attributesOrStartTime);
+    const time = getHrTime$1(startTime);
+    this.events.push({ name, attributes, time });
+    return this;
+  }
+  setStatus(status) {
+    this.status = status;
+    return this;
+  }
+  updateName(name) {
+    this.name = name;
+    return this;
+  }
+  end(endTime) {
+    if (this._ended) {
+      return;
+    }
+    this._ended = true;
+    this.endTime = getHrTime$1(endTime);
+    this._duration = hrTimeDuration(this.startTime, this.endTime);
+    this.onEnd(this);
+  }
+  isRecording() {
+    return !this._ended;
+  }
+  recordException(exception, time) {
+    const attributes = transformExceptionAttributes(exception);
+    this.addEvent("exception", attributes, time);
+  }
+  get duration() {
+    return this._duration;
+  }
+  get ended() {
+    return this._ended;
+  }
+  get droppedAttributesCount() {
+    return this._droppedAttributesCount;
+  }
+  get droppedEventsCount() {
+    return this._droppedEventsCount;
+  }
+  get droppedLinksCount() {
+    return this._droppedLinksCount;
+  }
+}
+
+const idGenerator = new RandomIdGenerator();
+let withNextSpanAttributes;
+function getFlagAt(flagSequence, position) {
+  return (flagSequence >> position - 1 & 1) * position;
+}
+class WorkerTracer {
+  spanProcessors;
+  resource;
+  constructor(spanProcessors, resource) {
+    this.spanProcessors = spanProcessors;
+    this.resource = resource;
+  }
+  async forceFlush(traceId) {
+    const promises = this.spanProcessors.map(async (spanProcessor) => {
+      await spanProcessor.forceFlush(traceId);
+    });
+    await Promise.allSettled(promises);
+  }
+  addToResource(extra) {
+    this.resource.merge(extra);
+  }
+  startSpan(name, options = {}, context$1 = context.active()) {
+    if (options.root) {
+      context$1 = trace.deleteSpan(context$1);
+    }
+    const config = getActiveConfig();
+    if (!config) throw new Error("Config is undefined. This is a bug in the instrumentation logic");
+    const parentSpanContext = trace.getSpan(context$1)?.spanContext();
+    const { traceId, randomTraceFlag } = getTraceInfo(parentSpanContext);
+    const spanKind = options.kind || SpanKind.INTERNAL;
+    const sanitisedAttrs = sanitizeAttributes(options.attributes);
+    const sampler = config.sampling.headSampler;
+    const samplingDecision = sampler.shouldSample(context$1, traceId, name, spanKind, sanitisedAttrs, []);
+    const { decision, traceState, attributes: attrs } = samplingDecision;
+    const attributes = Object.assign({}, options.attributes, attrs, withNextSpanAttributes);
+    withNextSpanAttributes = {};
+    const spanId = idGenerator.generateSpanId();
+    const parentSpanId = parentSpanContext?.spanId;
+    const sampleFlag = decision === SamplingDecision.RECORD_AND_SAMPLED ? TraceFlags.SAMPLED : TraceFlags.NONE;
+    const traceFlags = sampleFlag + randomTraceFlag;
+    const spanContext = { traceId, spanId, traceFlags, traceState };
+    const span = new SpanImpl({
+      attributes: sanitizeAttributes(attributes),
+      name,
+      onEnd: (span2) => {
+        this.spanProcessors.forEach((sp) => {
+          sp.onEnd(span2);
+        });
+      },
+      resource: this.resource,
+      spanContext,
+      parentSpanContext,
+      parentSpanId,
+      spanKind,
+      startTime: options.startTime
+    });
+    this.spanProcessors.forEach((sp) => {
+      sp.onStart(span, context$1);
+    });
+    return span;
+  }
+  startActiveSpan(name, ...args) {
+    const options = args.length > 1 ? args[0] : void 0;
+    const parentContext = args.length > 2 ? args[1] : context.active();
+    const fn = args[args.length - 1];
+    const span = this.startSpan(name, options, parentContext);
+    const contextWithSpanSet = trace.setSpan(parentContext, span);
+    return context.with(contextWithSpanSet, fn, void 0, span);
+  }
+}
+function withNextSpan(attrs) {
+  withNextSpanAttributes = Object.assign({}, withNextSpanAttributes, attrs);
+}
+function getTraceInfo(parentSpanContext) {
+  if (parentSpanContext && trace.isSpanContextValid(parentSpanContext)) {
+    const { traceId, traceFlags } = parentSpanContext;
+    return { traceId, randomTraceFlag: getFlagAt(traceFlags, 2) };
+  } else {
+    return { traceId: idGenerator.generateTraceId(), randomTraceFlag: 2 /* RANDOM_TRACE_ID_SET */ };
+  }
+}
+
+class WorkerTracerProvider {
+  spanProcessors;
+  resource;
+  tracers = {};
+  constructor(spanProcessors, resource) {
+    this.spanProcessors = spanProcessors;
+    this.resource = resource;
+  }
+  getTracer(name, version, options) {
+    const key = `${name}@${version || ""}:${options?.schemaUrl || ""}`;
+    if (!this.tracers[key]) {
+      this.tracers[key] = new WorkerTracer(this.spanProcessors, this.resource);
+    }
+    return this.tracers[key];
+  }
+  register() {
+    trace.setGlobalTracerProvider(this);
+    context.setGlobalContextManager(new AsyncLocalStorageContextManager());
+  }
+}
+
+function millisToHr(millis) {
+  return [Math.trunc(millis / 1e3), millis % 1e3 * 1e6];
+}
+function getHrTime(input) {
+  const now = Date.now();
+  if (!input) {
+    return millisToHr(now);
+  } else if (input instanceof Date) {
+    return millisToHr(input.getTime());
+  } else if (typeof input === "number") {
+    return millisToHr(input);
+  } else if (Array.isArray(input)) {
+    return input;
+  }
+  const v = input;
+  throw new Error(`unreachable value: ${JSON.stringify(v)}`);
+}
+class LogRecordImpl {
+  timeUnixNano;
+  observedTimeUnixNano;
+  severityNumber;
+  severityText;
+  body;
+  attributes;
+  traceId;
+  spanId;
+  traceFlags;
+  resource;
+  instrumentationScope;
+  droppedAttributesCount = 0;
+  constructor(init) {
+    this.timeUnixNano = getHrTime(init.timestamp);
+    this.observedTimeUnixNano = getHrTime(init.observedTimestamp);
+    this.severityNumber = init.severityNumber;
+    this.severityText = init.severityText;
+    this.body = init.body;
+    this.attributes = sanitizeAttributes(init.attributes || {});
+    this.resource = init.resource;
+    this.instrumentationScope = init.instrumentationScope || {
+      name: "@inference-net/otel-cf-workers"
+    };
+    const activeSpan = trace.getActiveSpan();
+    if (activeSpan && !init.traceId) {
+      const spanContext = activeSpan.spanContext();
+      this.traceId = spanContext.traceId;
+      this.spanId = spanContext.spanId;
+      this.traceFlags = spanContext.traceFlags;
+    } else {
+      this.traceId = init.traceId;
+      this.spanId = init.spanId;
+      this.traceFlags = init.traceFlags;
+    }
+  }
+}
+
+class WorkerLogger {
+  processors;
+  resource;
+  name;
+  version;
+  inheritedAttributes;
+  constructor(name, processors, resource, version, inheritedAttributes) {
+    this.name = name;
+    this.processors = processors;
+    this.resource = resource;
+    this.version = version;
+    this.inheritedAttributes = inheritedAttributes || {};
+  }
+  emit(logRecord) {
+    const mergedAttributes = {
+      ...this.inheritedAttributes,
+      ...logRecord.attributes || {}
+    };
+    const record = new LogRecordImpl({
+      ...logRecord,
+      attributes: mergedAttributes,
+      resource: this.resource,
+      instrumentationScope: {
+        name: this.name,
+        version: this.version
+      }
+    });
+    const context$1 = context.active();
+    this.processors.forEach((processor) => {
+      processor.onEmit(record, context$1);
+    });
+  }
+  trace(message, attributes) {
+    this.emit({
+      severityNumber: SEVERITY_NUMBERS.TRACE,
+      severityText: "TRACE",
+      body: message,
+      attributes
+    });
+  }
+  debug(message, attributes) {
+    this.emit({
+      severityNumber: SEVERITY_NUMBERS.DEBUG,
+      severityText: "DEBUG",
+      body: message,
+      attributes
+    });
+  }
+  info(message, attributes) {
+    this.emit({
+      severityNumber: SEVERITY_NUMBERS.INFO,
+      severityText: "INFO",
+      body: message,
+      attributes
+    });
+  }
+  warn(message, attributes) {
+    this.emit({
+      severityNumber: SEVERITY_NUMBERS.WARN,
+      severityText: "WARN",
+      body: message,
+      attributes
+    });
+  }
+  error(message, attributes) {
+    let body;
+    let attrs = { ...attributes };
+    if (message instanceof Error) {
+      body = message.message;
+      attrs = {
+        ...attrs,
+        "exception.type": message.name,
+        "exception.message": message.message,
+        "exception.stacktrace": message.stack
+      };
+    } else {
+      body = message;
+    }
+    this.emit({
+      severityNumber: SEVERITY_NUMBERS.ERROR,
+      severityText: "ERROR",
+      body,
+      attributes: attrs
+    });
+  }
+  fatal(message, attributes) {
+    this.emit({
+      severityNumber: SEVERITY_NUMBERS.FATAL,
+      severityText: "FATAL",
+      body: message,
+      attributes
+    });
+  }
+  async forceFlush() {
+    const promises = this.processors.map((p) => p.forceFlush());
+    await Promise.allSettled(promises);
+  }
+  /**
+   * Create a child logger that inherits attributes from this logger
+   * Child attributes are merged with parent attributes (child takes precedence)
+   */
+  child(attributes) {
+    const mergedAttributes = {
+      ...this.inheritedAttributes,
+      ...attributes
+    };
+    return new WorkerLogger(this.name, this.processors, this.resource, this.version, mergedAttributes);
+  }
+}
+
+let globalLoggerProvider;
+function setGlobalLoggerProvider(provider) {
+  globalLoggerProvider = provider;
+}
+function getGlobalLoggerProvider() {
+  return globalLoggerProvider || new NoopLoggerProvider();
+}
+class WorkerLoggerProvider {
+  loggers = /* @__PURE__ */ new Map();
+  processors;
+  resource;
+  constructor(processors, resource) {
+    this.processors = processors;
+    this.resource = resource;
+  }
+  getLogger(name, version, options) {
+    const key = `${name}@${version || ""}:${options?.schemaUrl || ""}`;
+    if (!this.loggers.has(key)) {
+      this.loggers.set(key, new WorkerLogger(name, this.processors, this.resource, version));
+    }
+    return this.loggers.get(key);
+  }
+  register() {
+    setGlobalLoggerProvider(this);
+  }
+  async shutdown() {
+    await Promise.allSettled(this.processors.map((p) => p.shutdown()));
+  }
+}
+class NoopLogger {
+  emit() {
+  }
+  trace() {
+  }
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+  fatal() {
+  }
+  async forceFlush() {
+  }
+  child() {
+    return this;
+  }
+}
+class NoopLoggerProvider {
+  logger = new NoopLogger();
+  getLogger() {
+    return this.logger;
+  }
+  register() {
+  }
+  async shutdown() {
+  }
+}
+function getLogger(name, version, options) {
+  return getGlobalLoggerProvider().getLogger(name, version, options);
+}
+
+const provider = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	WorkerLoggerProvider,
+	getGlobalLoggerProvider,
+	getLogger,
+	setGlobalLoggerProvider
+}, Symbol.toStringTag, { value: 'Module' }));
+
+function isValidAttributeValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function gatherUserAgentAttributes(request) {
+  const attrs = {};
+  if (!request.cf) {
+    return attrs;
+  }
+  const cfData = request.cf;
+  if (cfData["browser"]) {
+    const browser = cfData["browser"];
+    if (isValidAttributeValue(browser["name"])) attrs[ATTR_USER_AGENT_BROWSER_NAME] = browser["name"];
+    if (isValidAttributeValue(browser["version"])) attrs[ATTR_USER_AGENT_BROWSER_VERSION] = browser["version"];
+    if (isValidAttributeValue(browser["major"])) attrs[ATTR_USER_AGENT_BROWSER_MAJOR_VERSION] = browser["major"];
+  }
+  if (cfData["os"]) {
+    const os = cfData["os"];
+    if (isValidAttributeValue(os["name"])) attrs[ATTR_USER_AGENT_OS_NAME] = os["name"];
+    if (isValidAttributeValue(os["version"])) attrs[ATTR_USER_AGENT_OS_VERSION] = os["version"];
+  }
+  if (cfData["engine"]) {
+    const engine = cfData["engine"];
+    if (isValidAttributeValue(engine["name"])) attrs[ATTR_USER_AGENT_ENGINE_NAME] = engine["name"];
+    if (isValidAttributeValue(engine["version"])) attrs[ATTR_USER_AGENT_ENGINE_VERSION] = engine["version"];
+  }
+  if (cfData["device"]) {
+    const device = cfData["device"];
+    if (isValidAttributeValue(device["type"])) attrs[ATTR_USER_AGENT_DEVICE_TYPE] = device["type"];
+    if (isValidAttributeValue(device["vendor"])) attrs[ATTR_USER_AGENT_DEVICE_VENDOR] = device["vendor"];
+    if (isValidAttributeValue(device["model"])) attrs[ATTR_USER_AGENT_DEVICE_MODEL] = device["model"];
+  }
+  return attrs;
+}
+
+function gatherRootSpanAttributes(request, handlerType, executionModel = "stateless") {
+  const attrs = {
+    [ATTR_CLOUDFLARE_HANDLER_TYPE]: handlerType,
+    [ATTR_CLOUDFLARE_EXECUTION_MODEL]: executionModel
+  };
+  const rayId = request.headers?.get("cf-ray");
+  if (rayId) {
+    attrs[ATTR_CLOUDFLARE_RAY_ID] = rayId;
+  }
+  if (request.cf?.colo) {
+    attrs[ATTR_CLOUDFLARE_COLO] = request.cf.colo;
+  }
+  return attrs;
+}
+
+const netKeysFromCF = /* @__PURE__ */ new Set(["colo", "country", "request_priority", "tls_cipher", "tls_version", "asn", "tcp_rtt"]);
+const camelToSnakeCase = (s) => {
+  return s.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+};
+const gatherOutgoingCfAttributes = (cf) => {
+  const attrs = {};
+  Object.keys(cf).forEach((key) => {
+    const value = cf[key];
+    const destKey = camelToSnakeCase(key);
+    if (!netKeysFromCF.has(destKey)) {
+      if (typeof value === "string" || typeof value === "number") {
+        attrs[`cf.${destKey}`] = value;
+      } else {
+        attrs[`cf.${destKey}`] = JSON.stringify(value);
+      }
+    }
+  });
+  return attrs;
+};
+function gatherRequestAttributes(request) {
+  const attrs = {};
+  const headers = request.headers;
+  attrs["http.request.method"] = request.method.toUpperCase();
+  attrs["network.protocol.name"] = "http";
+  if (request.cf?.httpProtocol) {
+    attrs["network.protocol.version"] = request.cf.httpProtocol;
+  }
+  const contentLength = headers.get("content-length");
+  if (contentLength) {
+    attrs["http.request.body.size"] = parseInt(contentLength, 10);
+    attrs[ATTR_HTTP_REQUEST_HEADER_CONTENT_LENGTH] = contentLength;
+  }
+  const userAgent = headers.get("user-agent");
+  if (userAgent) attrs["user_agent.original"] = userAgent;
+  const contentType = headers.get("content-type");
+  if (contentType) {
+    attrs["http.mime_type"] = contentType;
+    attrs[ATTR_HTTP_REQUEST_HEADER_CONTENT_TYPE] = contentType;
+  }
+  const accept = headers.get("accept");
+  if (accept) attrs[ATTR_HTTP_REQUEST_HEADER_ACCEPT] = accept;
+  const acceptEncoding = headers.get("accept-encoding");
+  if (acceptEncoding) {
+    attrs["http.accepts"] = acceptEncoding;
+    attrs[ATTR_HTTP_REQUEST_HEADER_ACCEPT_ENCODING] = acceptEncoding;
+  }
+  const acceptLanguage = headers.get("accept-language");
+  if (acceptLanguage) attrs[ATTR_HTTP_REQUEST_HEADER_ACCEPT_LANGUAGE] = acceptLanguage;
+  const u = new URL(request.url);
+  attrs["url.full"] = `${u.protocol}//${u.host}${u.pathname}${u.search}`;
+  attrs["server.address"] = u.host;
+  attrs["url.scheme"] = u.protocol.replace(":", "");
+  attrs["url.path"] = u.pathname;
+  if (u.search) attrs["url.query"] = u.search;
+  if (u.port) {
+    attrs["server.port"] = parseInt(u.port, 10);
+  } else {
+    attrs["server.port"] = u.protocol === "https:" ? 443 : 80;
+  }
+  return attrs;
+}
+function gatherResponseAttributes(response) {
+  const attrs = {};
+  attrs["http.response.status_code"] = response.status;
+  if (response.headers.get("content-length") == null) {
+    attrs["http.response.body.size"] = response.headers.get("content-length");
+  }
+  attrs["http.mime_type"] = response.headers.get("content-type");
+  return attrs;
+}
+function gatherIncomingCfAttributes(request) {
+  const attrs = {};
+  if (!request.cf) {
+    return attrs;
+  }
+  if (request.cf.colo) attrs["net.colo"] = request.cf.colo;
+  if (request.cf.country) attrs["net.country"] = request.cf.country;
+  if (request.cf.requestPriority) attrs["net.request_priority"] = request.cf.requestPriority;
+  if (request.cf.tlsCipher) attrs["net.tls_cipher"] = request.cf.tlsCipher;
+  if (request.cf.tlsVersion) attrs["net.tls_version"] = request.cf.tlsVersion;
+  if (request.cf.asn) attrs[ATTR_CLOUDFLARE_ASN] = request.cf.asn;
+  if (request.cf.clientTcpRtt) attrs["net.tcp_rtt"] = request.cf.clientTcpRtt;
+  if (request.cf.timezone) attrs[ATTR_GEO_TIMEZONE] = request.cf.timezone;
+  if (request.cf.continent) attrs[ATTR_GEO_CONTINENT_CODE] = request.cf.continent;
+  if (request.cf.country) attrs[ATTR_GEO_COUNTRY_CODE] = request.cf.country;
+  if (request.cf.city) attrs[ATTR_GEO_LOCALITY_NAME] = request.cf.city;
+  if (request.cf.region) attrs[ATTR_GEO_LOCALITY_REGION] = request.cf.region;
+  if (request.cf.verifiedBotCategory) attrs[ATTR_CLOUDFLARE_VERIFIED_BOT_CATEGORY] = request.cf.verifiedBotCategory;
+  return attrs;
+}
+function getParentContextFromHeaders(headers) {
+  return propagation.extract(context.active(), headers, {
+    get(headers2, key) {
+      return headers2.get(key) || void 0;
+    },
+    keys(headers2) {
+      return [...headers2.keys()];
+    }
+  });
+}
+function getParentContextFromRequest(request) {
+  const workerConfig = getActiveConfig();
+  if (workerConfig === void 0) {
+    return context.active();
+  }
+  const acceptTraceContext = typeof workerConfig.handlers.fetch.acceptTraceContext === "function" ? workerConfig.handlers.fetch.acceptTraceContext(request) : workerConfig.handlers.fetch.acceptTraceContext ?? true;
+  return acceptTraceContext ? getParentContextFromHeaders(request.headers) : context.active();
+}
+function updateSpanNameOnRoute(span, request) {
+  const readable = span;
+  if (readable.attributes["http.route"]) {
+    const method = request.method.toUpperCase();
+    span.updateName(`${method} ${readable.attributes["http.route"]}`);
+  }
+}
+const fetchInstrumentation = {
+  getInitialSpanInfo: (request) => {
+    const spanContext = getParentContextFromRequest(request);
+    const attributes = {
+      ["faas.trigger"]: "http",
+      ["faas.invocation_id"]: request.headers.get("cf-ray") ?? void 0
+    };
+    Object.assign(attributes, gatherRequestAttributes(request));
+    Object.assign(attributes, gatherIncomingCfAttributes(request));
+    Object.assign(attributes, gatherRootSpanAttributes(request, "fetch"));
+    Object.assign(attributes, gatherUserAgentAttributes(request));
+    const method = request.method.toUpperCase();
+    return {
+      name: `fetchHandler ${method}`,
+      options: {
+        attributes,
+        kind: SpanKind.SERVER
+      },
+      context: spanContext
+    };
+  },
+  getAttributesFromResult: (response) => {
+    return gatherResponseAttributes(response);
+  },
+  executionSucces: updateSpanNameOnRoute,
+  executionFailed: updateSpanNameOnRoute
+};
+function instrumentClientFetch(fetchFn, configFn, attrs) {
+  const handler = {
+    apply: (target, thisArg, argArray) => {
+      const request = new Request(argArray[0], argArray[1]);
+      if (!request.url.startsWith("http")) {
+        return Reflect.apply(target, thisArg, argArray);
+      }
+      const workerConfig = getActiveConfig();
+      if (!workerConfig) {
+        return Reflect.apply(target, thisArg, [request]);
+      }
+      const config = configFn(workerConfig);
+      const tracer = trace.getTracer("fetcher");
+      const options = { kind: SpanKind.CLIENT, attributes: attrs };
+      const host = new URL(request.url).host;
+      const method = request.method.toUpperCase();
+      const spanName = typeof attrs?.["name"] === "string" ? attrs?.["name"] : `fetch ${method} ${host}`;
+      const promise = tracer.startActiveSpan(spanName, options, async (span) => {
+        try {
+          const includeTraceContext = typeof config.includeTraceContext === "function" ? config.includeTraceContext(request) : config.includeTraceContext;
+          if (includeTraceContext ?? true) {
+            propagation.inject(context.active(), request.headers, {
+              set: (h, k, v) => h.set(k, typeof v === "string" ? v : String(v))
+            });
+          }
+          span.setAttributes(gatherRequestAttributes(request));
+          if (request.cf) span.setAttributes(gatherOutgoingCfAttributes(request.cf));
+          const response = await Reflect.apply(target, thisArg, [request]);
+          span.setAttributes(gatherResponseAttributes(response));
+          return response;
+        } catch (error) {
+          span.recordException(error);
+          span.setStatus({ code: SpanStatusCode.ERROR });
+          throw error;
+        } finally {
+          span.end();
+        }
+      });
+      return promise;
+    }
+  };
+  return wrap(fetchFn, handler, true);
+}
+function instrumentGlobalFetch() {
+  globalThis.fetch = instrumentClientFetch(globalThis.fetch, (config) => config.fetch);
+}
+
+const tracer = trace.getTracer("cache instrumentation");
+function sanitiseURL(url) {
+  const u = new URL(url);
+  return `${u.protocol}//${u.host}${u.pathname}${u.search}`;
+}
+function instrumentFunction(fn, cacheName, op) {
+  const handler = {
+    async apply(target, thisArg, argArray) {
+      const attributes = {
+        "cache.name": cacheName,
+        "http.url": argArray[0].url ? sanitiseURL(argArray[0].url) : void 0,
+        "cache.operation": op
+      };
+      const options = { kind: SpanKind.CLIENT, attributes };
+      return tracer.startActiveSpan(`Cache ${cacheName} ${op}`, options, async (span) => {
+        const result = await Reflect.apply(target, thisArg, argArray);
+        if (op === "match") {
+          span.setAttribute("cache.hit", !!result);
+        }
+        span.end();
+        return result;
+      });
+    }
+  };
+  return wrap(fn, handler);
+}
+function instrumentCache(cache, cacheName) {
+  const handler = {
+    get(target, prop) {
+      if (prop === "delete" || prop === "match" || prop === "put") {
+        const fn = Reflect.get(target, prop).bind(target);
+        return instrumentFunction(fn, cacheName, prop);
+      } else {
+        return Reflect.get(target, prop);
+      }
+    }
+  };
+  return wrap(cache, handler);
+}
+function instrumentOpen(openFn) {
+  const handler = {
+    async apply(target, thisArg, argArray) {
+      const cacheName = argArray[0];
+      const cache = await Reflect.apply(target, thisArg, argArray);
+      return instrumentCache(cache, cacheName);
+    }
+  };
+  return wrap(openFn, handler);
+}
+function _instrumentGlobalCache() {
+  const handler = {
+    get(target, prop) {
+      if (prop === "default") {
+        const cache = target.default;
+        return instrumentCache(cache, "default");
+      } else if (prop === "open") {
+        const openFn = Reflect.get(target, prop).bind(target);
+        return instrumentOpen(openFn);
+      } else {
+        return Reflect.get(target, prop);
+      }
+    }
+  };
+  globalThis.caches = wrap(caches, handler);
+}
+function instrumentGlobalCache() {
+  return _instrumentGlobalCache();
+}
+
+class MessageStatusCount {
+  succeeded = 0;
+  failed = 0;
+  implicitly_acked = 0;
+  implicitly_retried = 0;
+  total;
+  constructor(total) {
+    this.total = total;
+  }
+  ack() {
+    this.succeeded = this.succeeded + 1;
+  }
+  ackRemaining() {
+    this.implicitly_acked = this.total - this.succeeded - this.failed;
+    this.succeeded = this.total - this.failed;
+  }
+  retry() {
+    this.failed = this.failed + 1;
+  }
+  retryRemaining() {
+    this.implicitly_retried = this.total - this.succeeded - this.failed;
+    this.failed = this.total - this.succeeded;
+  }
+  toAttributes() {
+    return {
+      "queue.messages_count": this.total,
+      "queue.messages_success": this.succeeded,
+      "queue.messages_failed": this.failed,
+      "queue.batch_success": this.succeeded === this.total,
+      "queue.implicitly_acked": this.implicitly_acked,
+      "queue.implicitly_retried": this.implicitly_retried
+    };
+  }
+}
+const addEvent = (name, msg) => {
+  const attrs = {};
+  if (msg) {
+    attrs["queue.message_id"] = msg.id;
+    attrs["queue.message_timestamp"] = msg.timestamp.toISOString();
+  }
+  trace.getActiveSpan()?.addEvent(name, attrs);
+};
+const proxyQueueMessage = (msg, count) => {
+  const msgHandler = {
+    get: (target, prop) => {
+      if (prop === "ack") {
+        const ackFn = Reflect.get(target, prop);
+        return new Proxy(ackFn, {
+          apply: (fnTarget) => {
+            addEvent("messageAck", msg);
+            count.ack();
+            Reflect.apply(fnTarget, msg, []);
+          }
+        });
+      } else if (prop === "retry") {
+        const retryFn = Reflect.get(target, prop);
+        return new Proxy(retryFn, {
+          apply: (fnTarget) => {
+            addEvent("messageRetry", msg);
+            count.retry();
+            const result = Reflect.apply(fnTarget, msg, []);
+            return result;
+          }
+        });
+      } else {
+        return Reflect.get(target, prop, msg);
+      }
+    }
+  };
+  return wrap(msg, msgHandler);
+};
+const proxyMessageBatch = (batch, count) => {
+  const batchHandler = {
+    get: (target, prop) => {
+      if (prop === "messages") {
+        const messages = Reflect.get(target, prop);
+        const messagesHandler = {
+          get: (target2, prop2) => {
+            if (typeof prop2 === "string" && !isNaN(parseInt(prop2))) {
+              const message = Reflect.get(target2, prop2);
+              return proxyQueueMessage(message, count);
+            } else {
+              return Reflect.get(target2, prop2);
+            }
+          }
+        };
+        return wrap(messages, messagesHandler);
+      } else if (prop === "ackAll") {
+        const ackFn = Reflect.get(target, prop);
+        return new Proxy(ackFn, {
+          apply: (fnTarget) => {
+            addEvent("ackAll");
+            count.ackRemaining();
+            Reflect.apply(fnTarget, batch, []);
+          }
+        });
+      } else if (prop === "retryAll") {
+        const retryFn = Reflect.get(target, prop);
+        return new Proxy(retryFn, {
+          apply: (fnTarget) => {
+            addEvent("retryAll");
+            count.retryRemaining();
+            Reflect.apply(fnTarget, batch, []);
+          }
+        });
+      }
+      return Reflect.get(target, prop);
+    }
+  };
+  return wrap(batch, batchHandler);
+};
+class QueueInstrumentation {
+  count;
+  getInitialSpanInfo(batch) {
+    return {
+      name: `queueHandler ${batch.queue}`,
+      options: {
+        attributes: {
+          [ATTR_FAAS_TRIGGER]: FAAS_TRIGGER_VALUE_PUBSUB,
+          [ATTR_CLOUDFLARE_QUEUE_NAME]: batch.queue,
+          [ATTR_CLOUDFLARE_QUEUE_BATCH_SIZE]: batch.messages.length
+        },
+        kind: SpanKind.CONSUMER
+      }
+    };
+  }
+  instrumentTrigger(batch) {
+    this.count = new MessageStatusCount(batch.messages.length);
+    return proxyMessageBatch(batch, this.count);
+  }
+  executionSucces(span) {
+    if (this.count) {
+      this.count.ackRemaining();
+      span.setAttributes(this.count.toAttributes());
+    }
+  }
+  executionFailed(span) {
+    if (this.count) {
+      this.count.retryRemaining();
+      span.setAttributes(this.count.toAttributes());
+    }
+  }
+}
+function instrumentQueueSend(fn, name) {
+  const tracer = trace.getTracer("queueSender");
+  const handler = {
+    apply: (target, thisArg, argArray) => {
+      return tracer.startActiveSpan(`Queues ${name} send`, async (span) => {
+        span.setAttribute("queue.operation", "send");
+        await Reflect.apply(target, unwrap(thisArg), argArray);
+        span.end();
+      });
+    }
+  };
+  return wrap(fn, handler);
+}
+function instrumentQueueSendBatch(fn, name) {
+  const tracer = trace.getTracer("queueSender");
+  const handler = {
+    apply: (target, thisArg, argArray) => {
+      return tracer.startActiveSpan(`Queues ${name} sendBatch`, async (span) => {
+        span.setAttribute("queue.operation", "sendBatch");
+        await Reflect.apply(target, unwrap(thisArg), argArray);
+        span.end();
+      });
+    }
+  };
+  return wrap(fn, handler);
+}
+function instrumentQueueSender(queue, name) {
+  const queueHandler = {
+    get: (target, prop) => {
+      if (prop === "send") {
+        const sendFn = Reflect.get(target, prop);
+        return instrumentQueueSend(sendFn, name);
+      } else if (prop === "sendBatch") {
+        const sendFn = Reflect.get(target, prop);
+        return instrumentQueueSendBatch(sendFn, name);
+      } else {
+        return Reflect.get(target, prop);
+      }
+    }
+  };
+  return wrap(queue, queueHandler);
+}
+
+const dbSystem$4 = "Cloudflare KV";
+const KVAttributes = {
+  delete(_argArray) {
+    return {};
+  },
+  get(argArray) {
+    const attrs = {};
+    const opts = argArray[1];
+    if (typeof opts === "string") {
+      attrs[ATTR_CLOUDFLARE_KV_QUERY_TYPE] = opts;
+    } else if (typeof opts === "object") {
+      if (opts.type) attrs[ATTR_CLOUDFLARE_KV_QUERY_TYPE] = opts.type;
+      if (opts.cacheTtl) attrs[ATTR_CLOUDFLARE_KV_QUERY_CACHE_TTL] = opts.cacheTtl;
+    }
+    return attrs;
+  },
+  getWithMetadata(argArray, result) {
+    const attrs = {};
+    const opts = argArray[1];
+    if (typeof opts === "string") {
+      attrs[ATTR_CLOUDFLARE_KV_QUERY_TYPE] = opts;
+    } else if (typeof opts === "object") {
+      if (opts.type) attrs[ATTR_CLOUDFLARE_KV_QUERY_TYPE] = opts.type;
+      if (opts.cacheTtl) attrs[ATTR_CLOUDFLARE_KV_QUERY_CACHE_TTL] = opts.cacheTtl;
+    }
+    const kvResult = result;
+    if (kvResult.metadata !== null && kvResult.metadata !== void 0) {
+      attrs[ATTR_CLOUDFLARE_KV_RESPONSE_METADATA] = JSON.stringify(kvResult.metadata);
+    }
+    if (kvResult.cacheStatus) {
+      attrs[ATTR_CLOUDFLARE_KV_RESPONSE_CACHE_STATUS] = kvResult.cacheStatus;
+    }
+    return attrs;
+  },
+  list(argArray, result) {
+    const attrs = {};
+    const opts = argArray[0] || {};
+    if (opts.cursor) attrs[ATTR_CLOUDFLARE_KV_QUERY_CURSOR] = opts.cursor;
+    if (opts.limit) attrs[ATTR_CLOUDFLARE_KV_QUERY_LIMIT] = opts.limit;
+    if (opts.prefix) attrs[ATTR_CLOUDFLARE_KV_QUERY_PREFIX] = opts.prefix;
+    const kvResult = result;
+    attrs[ATTR_CLOUDFLARE_KV_RESPONSE_LIST_COMPLETE] = kvResult.list_complete;
+    if (!kvResult.list_complete && kvResult.cursor) {
+      attrs[ATTR_CLOUDFLARE_KV_RESPONSE_CURSOR] = kvResult.cursor;
+    }
+    if (kvResult.cacheStatus) {
+      attrs[ATTR_CLOUDFLARE_KV_RESPONSE_CACHE_STATUS] = kvResult.cacheStatus;
+    }
+    return attrs;
+  },
+  put(argArray) {
+    const attrs = {};
+    const value = argArray[1];
+    if (value !== void 0) {
+      attrs[ATTR_CLOUDFLARE_KV_QUERY_VALUE_TYPE] = typeof value;
+    }
+    if (argArray.length > 2 && argArray[2]) {
+      const options = argArray[2];
+      if (options.expiration) attrs[ATTR_CLOUDFLARE_KV_QUERY_EXPIRATION] = options.expiration;
+      if (options.expirationTtl) attrs[ATTR_CLOUDFLARE_KV_QUERY_EXPIRATION_TTL] = options.expirationTtl;
+      if (options.metadata !== void 0) {
+        attrs[ATTR_CLOUDFLARE_KV_QUERY_METADATA] = JSON.stringify(options.metadata);
+      }
+    }
+    return attrs;
+  }
+};
+function instrumentKVFn(fn, name, operation) {
+  const tracer = trace.getTracer("KV");
+  const fnHandler = {
+    apply: (target, thisArg, argArray) => {
+      const attributes = {
+        [ATTR_CLOUDFLARE_BINDING_TYPE]: "KV",
+        [ATTR_CLOUDFLARE_BINDING_NAME]: name,
+        [SemanticAttributes.DB_NAME]: name,
+        [ATTR_DB_SYSTEM_NAME]: dbSystem$4,
+        [ATTR_DB_OPERATION_NAME]: operation
+      };
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`KV ${name} ${operation}`, options, async (span) => {
+        const result = await Reflect.apply(target, thisArg, argArray);
+        const extraAttrsFn = KVAttributes[operation];
+        const extraAttrs = extraAttrsFn ? extraAttrsFn(argArray, result) : {};
+        span.setAttributes(extraAttrs);
+        if (operation === "list") ; else if (Array.isArray(argArray[0])) {
+          const keys = argArray[0];
+          if (keys.length > 0 && keys[0]) {
+            span.setAttribute(ATTR_CLOUDFLARE_KV_QUERY_KEYS, keys[0]);
+            span.setAttribute(ATTR_CLOUDFLARE_KV_QUERY_KEYS_COUNT, keys.length);
+          }
+        } else if (argArray[0] && typeof argArray[0] === "string") {
+          span.setAttribute(ATTR_CLOUDFLARE_KV_QUERY_KEYS, argArray[0]);
+          span.setAttribute(ATTR_CLOUDFLARE_KV_QUERY_KEYS_COUNT, 1);
+        }
+        span.end();
+        return result;
+      });
+    }
+  };
+  return wrap(fn, fnHandler);
+}
+function instrumentKV(kv, name) {
+  const kvHandler = {
+    get: (target, prop, receiver) => {
+      const operation = String(prop);
+      const fn = Reflect.get(target, prop, receiver);
+      return instrumentKVFn(fn, name, operation);
+    }
+  };
+  return wrap(kv, kvHandler);
+}
+
+function instrumentServiceBinding(fetcher, envName) {
+  const fetcherHandler = {
+    get(target, prop) {
+      if (prop === "fetch") {
+        const fetcher2 = Reflect.get(target, prop);
+        const attrs = {
+          name: `Service Binding ${envName}`
+        };
+        return instrumentClientFetch(fetcher2, () => ({ includeTraceContext: true }), attrs);
+      } else {
+        return passthroughGet(target, prop);
+      }
+    }
+  };
+  return wrap(fetcher, fetcherHandler);
+}
+
+const dbSystem$3 = "Cloudflare D1";
+function metaAttributes(meta) {
+  return {
+    [ATTR_CLOUDFLARE_D1_RESPONSE_ROWS_READ]: meta.rows_read,
+    [ATTR_CLOUDFLARE_D1_RESPONSE_ROWS_WRITTEN]: meta.rows_written,
+    [ATTR_CLOUDFLARE_D1_RESPONSE_SQL_DURATION_MS]: meta.duration,
+    [ATTR_CLOUDFLARE_D1_RESPONSE_SIZE_AFTER]: meta.size_after,
+    [ATTR_CLOUDFLARE_D1_RESPONSE_LAST_ROW_ID]: meta.last_row_id,
+    [ATTR_CLOUDFLARE_D1_RESPONSE_CHANGED_DB]: meta.changed_db,
+    [ATTR_CLOUDFLARE_D1_RESPONSE_CHANGES]: meta.changes
+  };
+}
+function spanOptions(dbName, operation, sql) {
+  const attributes = {
+    [ATTR_CLOUDFLARE_BINDING_TYPE]: "D1",
+    [SemanticAttributes.DB_NAME]: dbName,
+    [ATTR_DB_SYSTEM_NAME]: dbSystem$3,
+    [ATTR_DB_OPERATION_NAME]: operation
+  };
+  if (sql) {
+    attributes[ATTR_DB_QUERY_TEXT] = sql;
+  }
+  return {
+    kind: SpanKind.CLIENT,
+    attributes
+  };
+}
+function instrumentD1StatementFn(fn, dbName, operation, sql) {
+  const tracer = trace.getTracer("D1");
+  const fnHandler = {
+    apply: (target, thisArg, argArray) => {
+      if (operation === "bind") {
+        const newStmt = Reflect.apply(target, thisArg, argArray);
+        return instrumentD1PreparedStatement(newStmt, dbName, sql);
+      }
+      const options = spanOptions(dbName, operation, sql);
+      return tracer.startActiveSpan(`${dbName} ${operation}`, options, async (span) => {
+        try {
+          const result = await Reflect.apply(target, thisArg, argArray);
+          if (operation === "all" || operation === "run") {
+            span.setAttributes(metaAttributes(result.meta));
+          }
+          span.setStatus({ code: SpanStatusCode.OK });
+          return result;
+        } catch (error) {
+          span.recordException(error);
+          span.setStatus({ code: SpanStatusCode.ERROR });
+          throw error;
+        } finally {
+          span.end();
+        }
+      });
+    }
+  };
+  return wrap(fn, fnHandler);
+}
+function instrumentD1PreparedStatement(stmt, dbName, statement) {
+  const statementHandler = {
+    get: (target, prop, receiver) => {
+      const operation = String(prop);
+      const fn = Reflect.get(target, prop, receiver);
+      if (typeof fn === "function") {
+        return instrumentD1StatementFn(fn, dbName, operation, statement);
+      }
+      return fn;
+    }
+  };
+  return wrap(stmt, statementHandler);
+}
+function instrumentD1Fn(fn, dbName, operation) {
+  const tracer = trace.getTracer("D1");
+  const fnHandler = {
+    apply: (target, thisArg, argArray) => {
+      if (operation === "prepare") {
+        const sql = argArray[0];
+        const stmt = Reflect.apply(target, thisArg, argArray);
+        return instrumentD1PreparedStatement(stmt, dbName, sql);
+      } else if (operation === "exec") {
+        const sql = argArray[0];
+        const options = spanOptions(dbName, operation, sql);
+        return tracer.startActiveSpan(`${dbName} ${operation}`, options, async (span) => {
+          try {
+            const result = await Reflect.apply(target, thisArg, argArray);
+            span.setStatus({ code: SpanStatusCode.OK });
+            return result;
+          } catch (error) {
+            span.recordException(error);
+            span.setStatus({ code: SpanStatusCode.ERROR });
+            throw error;
+          } finally {
+            span.end();
+          }
+        });
+      } else if (operation === "batch") {
+        const statements = argArray[0];
+        return tracer.startActiveSpan(`${dbName} ${operation}`, async (span) => {
+          span.setAttribute(ATTR_DB_OPERATION_BATCH_SIZE, statements.length);
+          const subSpans = statements.map(
+            (s) => tracer.startSpan(`${dbName} ${operation} > query`, spanOptions(dbName, operation, s.statement))
+          );
+          try {
+            const result = await Reflect.apply(target, thisArg, argArray);
+            result.forEach((r, i) => subSpans[i]?.setAttributes(metaAttributes(r.meta)));
+            span.setStatus({ code: SpanStatusCode.OK });
+            return result;
+          } catch (error) {
+            span.recordException(error);
+            span.setStatus({ code: SpanStatusCode.ERROR });
+            throw error;
+          } finally {
+            subSpans.forEach((s) => s.end());
+            span.end();
+          }
+        });
+      } else {
+        return Reflect.apply(target, thisArg, argArray);
+      }
+    }
+  };
+  return wrap(fn, fnHandler);
+}
+function instrumentD1(database, dbName) {
+  const dbHandler = {
+    get: (target, prop, receiver) => {
+      const operation = String(prop);
+      const fn = Reflect.get(target, prop, receiver);
+      if (typeof fn === "function") {
+        return instrumentD1Fn(fn, dbName, operation);
+      }
+      return fn;
+    }
+  };
+  return wrap(database, dbHandler);
+}
+
+const dbSystem$2 = "Cloudflare Analytics Engine";
+const AEAttributes = {
+  writeDataPoint(argArray) {
+    const attrs = {};
+    const opts = argArray[0];
+    if (typeof opts === "object") {
+      attrs["db.cf.ae.indexes"] = opts.indexes.length;
+      attrs["db.cf.ae.index"] = opts.indexes[0].toString();
+      attrs["db.cf.ae.doubles"] = opts.doubles.length;
+      attrs["db.cf.ae.blobs"] = opts.blobs.length;
+    }
+    return attrs;
+  }
+};
+function instrumentAEFn(fn, name, operation) {
+  const tracer = trace.getTracer("AnalyticsEngine");
+  const fnHandler = {
+    apply: (target, thisArg, argArray) => {
+      const attributes = {
+        binding_type: "AnalyticsEngine",
+        [SemanticAttributes.DB_NAME]: name,
+        [SemanticAttributes.DB_SYSTEM]: dbSystem$2,
+        [SemanticAttributes.DB_OPERATION]: operation
+      };
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`Analytics Engine ${name} ${operation}`, options, async (span) => {
+        const result = await Reflect.apply(target, thisArg, argArray);
+        const extraAttrsFn = AEAttributes[operation];
+        const extraAttrs = extraAttrsFn ? extraAttrsFn(argArray, result) : {};
+        span.setAttributes(extraAttrs);
+        span.setAttribute(SemanticAttributes.DB_STATEMENT, `${operation} ${argArray[0]}`);
+        span.end();
+        return result;
+      });
+    }
+  };
+  return wrap(fn, fnHandler);
+}
+function instrumentAnalyticsEngineDataset(dataset, name) {
+  const datasetHandler = {
+    get: (target, prop, receiver) => {
+      const operation = String(prop);
+      const fn = Reflect.get(target, prop, receiver);
+      return instrumentAEFn(fn, name, operation);
+    }
+  };
+  return wrap(dataset, datasetHandler);
+}
+
+const dbSystem$1 = "Cloudflare R2";
+function addObjectMetadata(attrs, obj) {
+  if (!obj) return;
+  attrs[ATTR_CLOUDFLARE_R2_RESPONSE_SIZE] = obj.size;
+  attrs[ATTR_CLOUDFLARE_R2_RESPONSE_ETAG] = obj.etag;
+  attrs[ATTR_CLOUDFLARE_R2_RESPONSE_VERSION] = obj.version;
+  attrs[ATTR_CLOUDFLARE_R2_RESPONSE_UPLOADED] = obj.uploaded.toISOString();
+  if (obj.httpMetadata) {
+    if (obj.httpMetadata.contentType) {
+      attrs[ATTR_CLOUDFLARE_R2_RESPONSE_HTTP_METADATA_CONTENT_TYPE] = obj.httpMetadata.contentType;
+    }
+    if (obj.httpMetadata.contentLanguage) {
+      attrs[ATTR_CLOUDFLARE_R2_RESPONSE_HTTP_METADATA_CONTENT_LANGUAGE] = obj.httpMetadata.contentLanguage;
+    }
+    if (obj.httpMetadata.contentDisposition) {
+      attrs[ATTR_CLOUDFLARE_R2_RESPONSE_HTTP_METADATA_CONTENT_DISPOSITION] = obj.httpMetadata.contentDisposition;
+    }
+    if (obj.httpMetadata.contentEncoding) {
+      attrs[ATTR_CLOUDFLARE_R2_RESPONSE_HTTP_METADATA_CONTENT_ENCODING] = obj.httpMetadata.contentEncoding;
+    }
+    if (obj.httpMetadata.cacheControl) {
+      attrs[ATTR_CLOUDFLARE_R2_RESPONSE_HTTP_METADATA_CACHE_CONTROL] = obj.httpMetadata.cacheControl;
+    }
+    if (obj.httpMetadata.cacheExpiry) {
+      attrs[ATTR_CLOUDFLARE_R2_RESPONSE_HTTP_METADATA_CACHE_EXPIRY] = obj.httpMetadata.cacheExpiry.toISOString();
+    }
+  }
+  if (obj.customMetadata && Object.keys(obj.customMetadata).length > 0) {
+    attrs[ATTR_CLOUDFLARE_R2_RESPONSE_CUSTOM_METADATA_KEYS] = Object.keys(obj.customMetadata).join(",");
+  }
+  if (obj.range) {
+    if ("offset" in obj.range && "length" in obj.range) {
+      const offset = obj.range.offset ?? 0;
+      const length = obj.range.length ?? 0;
+      attrs[ATTR_CLOUDFLARE_R2_RESPONSE_RANGE] = `${offset}-${offset + length - 1}`;
+    } else if ("suffix" in obj.range) {
+      attrs[ATTR_CLOUDFLARE_R2_RESPONSE_RANGE] = `suffix-${obj.range.suffix}`;
+    }
+  }
+  if (obj.storageClass) {
+    attrs[ATTR_CLOUDFLARE_R2_RESPONSE_STORAGE_CLASS] = obj.storageClass;
+  }
+  if (obj.checksums) {
+    if (obj.checksums.md5) {
+      attrs[ATTR_CLOUDFLARE_R2_RESPONSE_CHECKSUMS_MD5] = Array.from(new Uint8Array(obj.checksums.md5)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    if (obj.checksums.sha1) {
+      attrs[ATTR_CLOUDFLARE_R2_RESPONSE_CHECKSUMS_SHA1] = Array.from(new Uint8Array(obj.checksums.sha1)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    if (obj.checksums.sha256) {
+      attrs[ATTR_CLOUDFLARE_R2_RESPONSE_CHECKSUMS_SHA256] = Array.from(new Uint8Array(obj.checksums.sha256)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    if (obj.checksums.sha384) {
+      attrs[ATTR_CLOUDFLARE_R2_RESPONSE_CHECKSUMS_SHA384] = Array.from(new Uint8Array(obj.checksums.sha384)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    if (obj.checksums.sha512) {
+      attrs[ATTR_CLOUDFLARE_R2_RESPONSE_CHECKSUMS_SHA512] = Array.from(new Uint8Array(obj.checksums.sha512)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+  }
+}
+function instrumentHead(fn, name) {
+  const tracer = trace.getTracer("r2");
+  const handler = {
+    apply: (target, thisArg, argArray) => {
+      const key = argArray[0];
+      const attributes = {
+        [ATTR_CLOUDFLARE_BINDING_TYPE]: "R2",
+        [ATTR_CLOUDFLARE_BINDING_NAME]: name,
+        [ATTR_DB_SYSTEM_NAME]: dbSystem$1,
+        [ATTR_DB_OPERATION_NAME]: "head",
+        [ATTR_DB_QUERY_TEXT]: key,
+        [ATTR_CLOUDFLARE_R2_QUERY_KEY]: key
+      };
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`R2 ${name} head`, options, async (span) => {
+        const result = await Reflect.apply(target, thisArg, argArray);
+        addObjectMetadata(attributes, result);
+        span.setAttributes(attributes);
+        span.end();
+        return result;
+      });
+    }
+  };
+  return wrap(fn, handler);
+}
+function instrumentGet(fn, name) {
+  const tracer = trace.getTracer("r2");
+  const handler = {
+    apply: (target, thisArg, argArray) => {
+      const key = argArray[0];
+      const getOptions = argArray[1];
+      const attributes = {
+        [ATTR_CLOUDFLARE_BINDING_TYPE]: "R2",
+        [ATTR_CLOUDFLARE_BINDING_NAME]: name,
+        [ATTR_DB_SYSTEM_NAME]: dbSystem$1,
+        [ATTR_DB_OPERATION_NAME]: "get",
+        [ATTR_DB_QUERY_TEXT]: key,
+        [ATTR_CLOUDFLARE_R2_QUERY_KEY]: key
+      };
+      if (getOptions) {
+        if (getOptions.range) {
+          if ("offset" in getOptions.range) {
+            attributes[ATTR_CLOUDFLARE_R2_QUERY_OFFSET] = getOptions.range.offset;
+            if ("length" in getOptions.range) {
+              attributes[ATTR_CLOUDFLARE_R2_QUERY_LENGTH] = getOptions.range.length;
+            }
+          } else if ("suffix" in getOptions.range) {
+            attributes[ATTR_CLOUDFLARE_R2_QUERY_SUFFIX] = getOptions.range.suffix;
+          }
+        }
+        if (getOptions.onlyIf) {
+          attributes[ATTR_CLOUDFLARE_R2_QUERY_ONLY_IF] = JSON.stringify(getOptions.onlyIf);
+        }
+      }
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`R2 ${name} get`, options, async (span) => {
+        const result = await Reflect.apply(target, thisArg, argArray);
+        addObjectMetadata(attributes, result);
+        span.setAttributes(attributes);
+        span.end();
+        return result;
+      });
+    }
+  };
+  return wrap(fn, handler);
+}
+function instrumentPut(fn, name) {
+  const tracer = trace.getTracer("r2");
+  const handler = {
+    apply: (target, thisArg, argArray) => {
+      const key = argArray[0];
+      const putOptions = argArray[2];
+      const attributes = {
+        [ATTR_CLOUDFLARE_BINDING_TYPE]: "R2",
+        [ATTR_CLOUDFLARE_BINDING_NAME]: name,
+        [ATTR_DB_SYSTEM_NAME]: dbSystem$1,
+        [ATTR_DB_OPERATION_NAME]: "put",
+        [ATTR_DB_QUERY_TEXT]: key,
+        [ATTR_CLOUDFLARE_R2_QUERY_KEY]: key
+      };
+      if (putOptions) {
+        if (putOptions.httpMetadata) {
+          attributes[ATTR_CLOUDFLARE_R2_PUT_HTTP_METADATA] = true;
+        }
+        if (putOptions.customMetadata) {
+          attributes[ATTR_CLOUDFLARE_R2_PUT_CUSTOM_METADATA] = Object.keys(putOptions.customMetadata).join(",");
+        }
+        if (putOptions.md5) {
+          attributes[ATTR_CLOUDFLARE_R2_PUT_MD5] = true;
+        }
+        if (putOptions.sha1) {
+          attributes[ATTR_CLOUDFLARE_R2_PUT_SHA1] = true;
+        }
+        if (putOptions.sha256) {
+          attributes[ATTR_CLOUDFLARE_R2_PUT_SHA256] = true;
+        }
+        if (putOptions.sha384) {
+          attributes[ATTR_CLOUDFLARE_R2_PUT_SHA384] = true;
+        }
+        if (putOptions.sha512) {
+          attributes[ATTR_CLOUDFLARE_R2_PUT_SHA512] = true;
+        }
+        if (putOptions.storageClass) {
+          attributes[ATTR_CLOUDFLARE_R2_PUT_STORAGE_CLASS] = putOptions.storageClass;
+        }
+      }
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`R2 ${name} put`, options, async (span) => {
+        const result = await Reflect.apply(target, thisArg, argArray);
+        addObjectMetadata(attributes, result);
+        span.setAttributes(attributes);
+        span.end();
+        return result;
+      });
+    }
+  };
+  return wrap(fn, handler);
+}
+function instrumentDelete(fn, name) {
+  const tracer = trace.getTracer("r2");
+  const handler = {
+    apply: (target, thisArg, argArray) => {
+      const keys = argArray[0];
+      const isArray = Array.isArray(keys);
+      const attributes = {
+        [ATTR_CLOUDFLARE_BINDING_TYPE]: "R2",
+        [ATTR_CLOUDFLARE_BINDING_NAME]: name,
+        [ATTR_DB_SYSTEM_NAME]: dbSystem$1,
+        [ATTR_DB_OPERATION_NAME]: "delete"
+      };
+      if (isArray) {
+        if (keys.length > 0) {
+          attributes[ATTR_DB_QUERY_TEXT] = keys[0];
+          attributes[ATTR_CLOUDFLARE_R2_QUERY_KEY] = keys[0];
+        }
+      } else {
+        attributes[ATTR_DB_QUERY_TEXT] = keys;
+        attributes[ATTR_CLOUDFLARE_R2_QUERY_KEY] = keys;
+      }
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`R2 ${name} delete`, options, async (span) => {
+        await Reflect.apply(target, thisArg, argArray);
+        span.end();
+      });
+    }
+  };
+  return wrap(fn, handler);
+}
+function instrumentList(fn, name) {
+  const tracer = trace.getTracer("r2");
+  const handler = {
+    apply: (target, thisArg, argArray) => {
+      const listOptions = argArray[0];
+      const attributes = {
+        [ATTR_CLOUDFLARE_BINDING_TYPE]: "R2",
+        [ATTR_CLOUDFLARE_BINDING_NAME]: name,
+        [ATTR_DB_SYSTEM_NAME]: dbSystem$1,
+        [ATTR_DB_OPERATION_NAME]: "list"
+      };
+      if (listOptions) {
+        if (listOptions.prefix) {
+          attributes[ATTR_CLOUDFLARE_R2_QUERY_PREFIX] = listOptions.prefix;
+        }
+        if (listOptions.limit) {
+          attributes[ATTR_CLOUDFLARE_R2_QUERY_LIMIT] = listOptions.limit;
+        }
+        if (listOptions.delimiter) {
+          attributes[ATTR_CLOUDFLARE_R2_QUERY_DELIMITER] = listOptions.delimiter;
+        }
+        if (listOptions.startAfter) {
+          attributes[ATTR_CLOUDFLARE_R2_QUERY_START_AFTER] = listOptions.startAfter;
+        }
+        if (listOptions.include) {
+          attributes[ATTR_CLOUDFLARE_R2_QUERY_INCLUDE] = listOptions.include.join(",");
+        }
+        if (listOptions.cursor) {
+          attributes[ATTR_CLOUDFLARE_R2_LIST_CURSOR] = listOptions.cursor;
+        }
+      }
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`R2 ${name} list`, options, async (span) => {
+        const result = await Reflect.apply(target, thisArg, argArray);
+        attributes[ATTR_CLOUDFLARE_R2_LIST_TRUNCATED] = result.truncated;
+        attributes[ATTR_CLOUDFLARE_R2_LIST_OBJECTS_COUNT] = result.objects.length;
+        if (result.delimitedPrefixes) {
+          attributes[ATTR_CLOUDFLARE_R2_LIST_DELIMITED_PREFIXES_COUNT] = result.delimitedPrefixes.length;
+        }
+        if (result.truncated && "cursor" in result && result.cursor) {
+          attributes[ATTR_CLOUDFLARE_R2_LIST_CURSOR] = result.cursor;
+        }
+        span.setAttributes(attributes);
+        span.end();
+        return result;
+      });
+    }
+  };
+  return wrap(fn, handler);
+}
+function instrumentCreateMultipartUpload(fn, name) {
+  const tracer = trace.getTracer("r2");
+  const handler = {
+    apply: (target, thisArg, argArray) => {
+      const key = argArray[0];
+      const attributes = {
+        [ATTR_CLOUDFLARE_BINDING_TYPE]: "R2",
+        [ATTR_CLOUDFLARE_BINDING_NAME]: name,
+        [ATTR_DB_SYSTEM_NAME]: dbSystem$1,
+        [ATTR_DB_OPERATION_NAME]: "createMultipartUpload",
+        [ATTR_DB_QUERY_TEXT]: key,
+        [ATTR_CLOUDFLARE_R2_QUERY_KEY]: key
+      };
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`R2 ${name} createMultipartUpload`, options, async (span) => {
+        const result = await Reflect.apply(target, thisArg, argArray);
+        attributes[ATTR_CLOUDFLARE_R2_MULTIPART_UPLOAD_ID] = result.uploadId;
+        span.setAttributes(attributes);
+        span.end();
+        return result;
+      });
+    }
+  };
+  return wrap(fn, handler);
+}
+function instrumentResumeMultipartUpload(fn, name) {
+  const tracer = trace.getTracer("r2");
+  const handler = {
+    apply: (target, thisArg, argArray) => {
+      const key = argArray[0];
+      const uploadId = argArray[1];
+      const attributes = {
+        [ATTR_CLOUDFLARE_BINDING_TYPE]: "R2",
+        [ATTR_CLOUDFLARE_BINDING_NAME]: name,
+        [ATTR_DB_SYSTEM_NAME]: dbSystem$1,
+        [ATTR_DB_OPERATION_NAME]: "resumeMultipartUpload",
+        [ATTR_DB_QUERY_TEXT]: key,
+        [ATTR_CLOUDFLARE_R2_QUERY_KEY]: key,
+        [ATTR_CLOUDFLARE_R2_MULTIPART_UPLOAD_ID]: uploadId
+      };
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`R2 ${name} resumeMultipartUpload`, options, async (span) => {
+        const result = await Reflect.apply(target, thisArg, argArray);
+        span.end();
+        return result;
+      });
+    }
+  };
+  return wrap(fn, handler);
+}
+function instrumentR2Bucket(bucket, name) {
+  const bucketHandler = {
+    get: (target, prop, receiver) => {
+      const operation = String(prop);
+      const fn = Reflect.get(target, prop, receiver);
+      if (typeof fn !== "function") {
+        return fn;
+      }
+      switch (operation) {
+        case "head":
+          return instrumentHead(fn, name);
+        case "get":
+          return instrumentGet(fn, name);
+        case "put":
+          return instrumentPut(fn, name);
+        case "delete":
+          return instrumentDelete(fn, name);
+        case "list":
+          return instrumentList(fn, name);
+        case "createMultipartUpload":
+          return instrumentCreateMultipartUpload(fn, name);
+        case "resumeMultipartUpload":
+          return instrumentResumeMultipartUpload(fn, name);
+        default:
+          return fn;
+      }
+    }
+  };
+  return wrap(bucket, bucketHandler);
+}
+
+function instrumentImagesGet(fn, name) {
+  const tracer = trace.getTracer("images");
+  const handler = {
+    apply: (target, thisArg, argArray) => {
+      const key = argArray[0];
+      const attributes = {
+        [ATTR_CLOUDFLARE_BINDING_TYPE]: "Images",
+        [ATTR_CLOUDFLARE_BINDING_NAME]: name,
+        [ATTR_CLOUDFLARE_IMAGES_KEY]: key
+      };
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`Images ${name} get`, options, async (span) => {
+        const result = await Reflect.apply(target, thisArg, argArray);
+        if (result && typeof result === "object") {
+          if (result.id) {
+            attributes[ATTR_CLOUDFLARE_IMAGES_RESPONSE_ID] = result.id;
+          }
+          if (result.filename) {
+            attributes[ATTR_CLOUDFLARE_IMAGES_RESPONSE_FILENAME] = result.filename;
+          }
+          if (result.uploaded) {
+            attributes[ATTR_CLOUDFLARE_IMAGES_UPLOADED] = result.uploaded;
+          }
+          if (result.metadata && typeof result.metadata === "object") {
+            attributes[ATTR_CLOUDFLARE_IMAGES_METADATA_KEYS] = Object.keys(result.metadata).join(",");
+          }
+          if (result.variants && Array.isArray(result.variants)) {
+            attributes[ATTR_CLOUDFLARE_IMAGES_VARIANTS_COUNT] = result.variants.length;
+          }
+          if (typeof result.requireSignedURLs === "boolean") {
+            attributes[ATTR_CLOUDFLARE_IMAGES_REQUIRE_SIGNED_URLS] = result.requireSignedURLs;
+          }
+        }
+        span.setAttributes(attributes);
+        span.end();
+        return result;
+      });
+    }
+  };
+  return wrap(fn, handler);
+}
+function instrumentImagesList(fn, name) {
+  const tracer = trace.getTracer("images");
+  const handler = {
+    apply: (target, thisArg, argArray) => {
+      const attributes = {
+        [ATTR_CLOUDFLARE_BINDING_TYPE]: "Images",
+        [ATTR_CLOUDFLARE_BINDING_NAME]: name
+      };
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`Images ${name} list`, options, async (span) => {
+        const result = await Reflect.apply(target, thisArg, argArray);
+        if (result && typeof result === "object" && Array.isArray(result.images)) {
+          span.setAttribute("cloudflare.images.list.count", result.images.length);
+        }
+        span.end();
+        return result;
+      });
+    }
+  };
+  return wrap(fn, handler);
+}
+function instrumentImagesDelete(fn, name) {
+  const tracer = trace.getTracer("images");
+  const handler = {
+    apply: (target, thisArg, argArray) => {
+      const key = argArray[0];
+      const attributes = {
+        [ATTR_CLOUDFLARE_BINDING_TYPE]: "Images",
+        [ATTR_CLOUDFLARE_BINDING_NAME]: name,
+        [ATTR_CLOUDFLARE_IMAGES_KEY]: key
+      };
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`Images ${name} delete`, options, async (span) => {
+        await Reflect.apply(target, thisArg, argArray);
+        span.end();
+      });
+    }
+  };
+  return wrap(fn, handler);
+}
+function instrumentImagesBinding(images, name) {
+  const imagesHandler = {
+    get: (target, prop, receiver) => {
+      const fn = Reflect.get(target, prop, receiver);
+      if (typeof fn !== "function") {
+        return fn;
+      }
+      switch (String(prop)) {
+        case "get":
+          return instrumentImagesGet(fn, name);
+        case "list":
+          return instrumentImagesList(fn, name);
+        case "delete":
+          return instrumentImagesDelete(fn, name);
+        default:
+          return fn;
+      }
+    }
+  };
+  return wrap(images, imagesHandler);
+}
+
+function instrumentRateLimitLimit(fn, name) {
+  const tracer = trace.getTracer("rate_limit");
+  const handler = {
+    apply: (target, thisArg, argArray) => {
+      const options = argArray[0];
+      const attributes = {
+        [ATTR_CLOUDFLARE_BINDING_TYPE]: "RateLimit",
+        [ATTR_CLOUDFLARE_BINDING_NAME]: name,
+        [ATTR_CLOUDFLARE_RATE_LIMIT_KEY]: options.key
+      };
+      const spanOptions = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`RateLimit ${name} limit`, spanOptions, async (span) => {
+        const result = await Reflect.apply(target, thisArg, argArray);
+        if (result && typeof result === "object") {
+          attributes[ATTR_CLOUDFLARE_RATE_LIMIT_SUCCESS] = result.success;
+          attributes[ATTR_CLOUDFLARE_RATE_LIMIT_ALLOWED] = result.success;
+        }
+        span.setAttributes(attributes);
+        span.end();
+        return result;
+      });
+    }
+  };
+  return wrap(fn, handler);
+}
+function instrumentRateLimitBinding(rateLimit, name) {
+  const rateLimitHandler = {
+    get: (target, prop, receiver) => {
+      const fn = Reflect.get(target, prop, receiver);
+      if (typeof fn !== "function") {
+        return fn;
+      }
+      switch (String(prop)) {
+        case "limit":
+          return instrumentRateLimitLimit(fn, name);
+        default:
+          return fn;
+      }
+    }
+  };
+  return wrap(rateLimit, rateLimitHandler);
+}
+
+const isJSRPC = (item) => {
+  return !!item?.["__some_property_that_will_never_exist" + Math.random()];
+};
+const isKVNamespace = (item) => {
+  return !isJSRPC(item) && !!item?.getWithMetadata;
+};
+const isQueue = (item) => {
+  return !isJSRPC(item) && !!item?.sendBatch;
+};
+const isDurableObject = (item) => {
+  return !isJSRPC(item) && !!item?.idFromName;
+};
+const isVersionMetadata = (item) => {
+  return !isJSRPC(item) && typeof item?.id === "string" && typeof item?.tag === "string";
+};
+const isAnalyticsEngineDataset = (item) => {
+  return !isJSRPC(item) && !!item?.writeDataPoint;
+};
+const isD1Database = (item) => {
+  return !!item?.exec && !!item?.prepare;
+};
+const isR2Bucket = (item) => {
+  return !isJSRPC(item) && !!item?.head && !!item?.list;
+};
+const isImagesBinding = (item) => {
+  const obj = item;
+  return !isJSRPC(item) && typeof obj?.get === "function" && typeof obj?.list === "function" && typeof obj?.delete === "function" && // Distinguish from other bindings with similar methods
+  !isR2Bucket(item) && !isKVNamespace(item);
+};
+const isRateLimitBinding = (item) => {
+  const obj = item;
+  return !isJSRPC(item) && typeof obj?.limit === "function" && !isDurableObject(item);
+};
+const instrumentEnv = (env) => {
+  const envHandler = {
+    get: (target, prop, receiver) => {
+      const item = Reflect.get(target, prop, receiver);
+      if (!isProxyable(item)) {
+        return item;
+      }
+      if (isJSRPC(item)) {
+        return instrumentServiceBinding(item, String(prop));
+      } else if (isKVNamespace(item)) {
+        return instrumentKV(item, String(prop));
+      } else if (isQueue(item)) {
+        return instrumentQueueSender(item, String(prop));
+      } else if (isDurableObject(item)) {
+        return instrumentDOBinding(item, String(prop));
+      } else if (isVersionMetadata(item)) {
+        return item;
+      } else if (isAnalyticsEngineDataset(item)) {
+        return instrumentAnalyticsEngineDataset(item, String(prop));
+      } else if (isD1Database(item)) {
+        return instrumentD1(item, String(prop));
+      } else if (isR2Bucket(item)) {
+        return instrumentR2Bucket(item, String(prop));
+      } else if (isImagesBinding(item)) {
+        return instrumentImagesBinding(item, String(prop));
+      } else if (isRateLimitBinding(item)) {
+        return instrumentRateLimitBinding(item, String(prop));
+      } else {
+        return item;
+      }
+    }
+  };
+  return wrap(env, envHandler);
+};
+
+const dbSystem = "Cloudflare DO";
+function isDurableObjectCommonOptions(options) {
+  return typeof options === "object" && ("allowConcurrency" in options || "allowUnconfirmed" in options || "noCache" in options);
+}
+function applyOptionsAttributes(attrs, options) {
+  if ("allowConcurrency" in options) {
+    attrs[ATTR_CLOUDFLARE_DO_ALLOW_CONCURRENCY] = options.allowConcurrency;
+  }
+  if ("allowUnconfirmed" in options) {
+    attrs[ATTR_CLOUDFLARE_DO_ALLOW_UNCONFIRMED] = options.allowUnconfirmed;
+  }
+  if ("noCache" in options) {
+    attrs[ATTR_CLOUDFLARE_DO_NO_CACHE] = options.noCache;
+  }
+}
+const StorageAttributes = {
+  delete(argArray, result) {
+    const args = argArray;
+    let attrs = {};
+    if (Array.isArray(args[0])) {
+      const keys = args[0];
+      attrs = {
+        [ATTR_CLOUDFLARE_DO_KV_QUERY_KEYS]: keys[0],
+        [ATTR_CLOUDFLARE_DO_KV_QUERY_KEYS_COUNT]: keys.length,
+        [ATTR_CLOUDFLARE_DO_KV_RESPONSE_DELETED_COUNT]: result
+      };
+    } else {
+      attrs = {
+        [ATTR_CLOUDFLARE_DO_KV_QUERY_KEYS]: args[0]
+      };
+    }
+    if (args[1]) {
+      applyOptionsAttributes(attrs, args[1]);
+    }
+    return attrs;
+  },
+  deleteAll(argArray) {
+    const args = argArray;
+    let attrs = {};
+    if (args[0]) {
+      applyOptionsAttributes(attrs, args[0]);
+    }
+    return attrs;
+  },
+  get(argArray) {
+    const args = argArray;
+    let attrs = {};
+    if (Array.isArray(args[0])) {
+      const keys = args[0];
+      attrs = {
+        [ATTR_CLOUDFLARE_DO_KV_QUERY_KEYS]: keys[0],
+        [ATTR_CLOUDFLARE_DO_KV_QUERY_KEYS_COUNT]: keys.length
+      };
+    } else {
+      attrs = {
+        [ATTR_CLOUDFLARE_DO_KV_QUERY_KEYS]: args[0]
+      };
+    }
+    if (args[1]) {
+      applyOptionsAttributes(attrs, args[1]);
+    }
+    return attrs;
+  },
+  list(argArray) {
+    const args = argArray;
+    const attrs = {};
+    if (args[0]) {
+      const options = args[0];
+      applyOptionsAttributes(attrs, options);
+      if ("start" in options) {
+        attrs[ATTR_CLOUDFLARE_DO_KV_QUERY_START] = options.start;
+      }
+      if ("startAfter" in options) {
+        attrs[ATTR_CLOUDFLARE_DO_KV_QUERY_START_AFTER] = options.startAfter;
+      }
+      if ("end" in options) {
+        attrs[ATTR_CLOUDFLARE_DO_KV_QUERY_END] = options.end;
+      }
+      if ("prefix" in options) {
+        attrs[ATTR_CLOUDFLARE_DO_KV_QUERY_PREFIX] = options.prefix;
+      }
+      if ("reverse" in options) {
+        attrs[ATTR_CLOUDFLARE_DO_KV_QUERY_REVERSE] = options.reverse;
+      }
+      if ("limit" in options) {
+        attrs[ATTR_CLOUDFLARE_DO_KV_QUERY_LIMIT] = options.limit;
+      }
+    }
+    return attrs;
+  },
+  put(argArray) {
+    const args = argArray;
+    const attrs = {};
+    if (typeof args[0] === "string") {
+      attrs[ATTR_CLOUDFLARE_DO_KV_QUERY_KEYS] = args[0];
+      if (args[2]) {
+        applyOptionsAttributes(attrs, args[2]);
+      }
+    } else {
+      const keys = Object.keys(args[0]);
+      attrs[ATTR_CLOUDFLARE_DO_KV_QUERY_KEYS] = keys[0];
+      attrs[ATTR_CLOUDFLARE_DO_KV_QUERY_KEYS_COUNT] = keys.length;
+      if (isDurableObjectCommonOptions(args[1])) {
+        applyOptionsAttributes(attrs, args[1]);
+      }
+    }
+    return attrs;
+  },
+  getAlarm(argArray) {
+    const args = argArray;
+    const attrs = {};
+    if (args[0]) {
+      applyOptionsAttributes(attrs, args[0]);
+    }
+    return attrs;
+  },
+  setAlarm(argArray) {
+    const args = argArray;
+    const attrs = {};
+    if (args[0] instanceof Date) {
+      attrs["db.cf.do.alarm_time"] = args[0].getTime();
+    } else {
+      attrs["db.cf.do.alarm_time"] = args[0];
+    }
+    if (args[1]) {
+      applyOptionsAttributes(attrs, args[1]);
+    }
+    return attrs;
+  },
+  deleteAlarm(argArray) {
+    const args = argArray;
+    const attrs = {};
+    if (args[0]) {
+      applyOptionsAttributes(attrs, args[0]);
+    }
+    return attrs;
+  }
+};
+function instrumentStorageFn(fn, operation) {
+  const tracer = trace.getTracer("do_storage");
+  const fnHandler = {
+    apply: (target, thisArg, argArray) => {
+      const attributes = {
+        [ATTR_DB_SYSTEM_NAME]: dbSystem,
+        [ATTR_DB_OPERATION_NAME]: operation
+      };
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`Durable Object Storage ${operation}`, options, async (span) => {
+        const result = await Reflect.apply(target, thisArg, argArray);
+        const extraAttrsFn = StorageAttributes[operation];
+        const extraAttrs = extraAttrsFn ? extraAttrsFn(argArray, result) : {};
+        span.setAttributes(extraAttrs);
+        span.end();
+        return result;
+      });
+    }
+  };
+  return wrap(fn, fnHandler);
+}
+function instrumentStorage(storage) {
+  const storageHandler = {
+    get: (target, prop, receiver) => {
+      const operation = String(prop);
+      const fn = Reflect.get(target, prop, receiver);
+      if (prop === "sql" && typeof fn === "object" && fn !== null) {
+        return instrumentSQLStorage(fn);
+      }
+      return instrumentStorageFn(fn, operation);
+    }
+  };
+  return wrap(storage, storageHandler);
+}
+function instrumentSQLStorageExec(fn, operation) {
+  const tracer = trace.getTracer("do_sql_storage");
+  const fnHandler = {
+    apply: (target, thisArg, argArray) => {
+      const query = argArray[0];
+      const bindings = argArray[1];
+      const attributes = {
+        [ATTR_DB_SYSTEM_NAME]: dbSystem,
+        [ATTR_DB_OPERATION_NAME]: operation,
+        [ATTR_DB_QUERY_TEXT]: query
+      };
+      if (bindings && bindings.length > 0) {
+        attributes[ATTR_CLOUDFLARE_DO_SQL_QUERY_BINDINGS] = bindings.length;
+      }
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`Durable Object SQL ${operation}`, options, async (span) => {
+        const result = await Reflect.apply(target, thisArg, argArray);
+        if (result && typeof result === "object") {
+          if ("rowsRead" in result) {
+            span.setAttribute(ATTR_CLOUDFLARE_DO_SQL_RESPONSE_ROWS_READ, result.rowsRead);
+          }
+          if ("rowsWritten" in result) {
+            span.setAttribute(ATTR_CLOUDFLARE_DO_SQL_RESPONSE_ROWS_WRITTEN, result.rowsWritten);
+          }
+        }
+        span.end();
+        return result;
+      });
+    }
+  };
+  return wrap(fn, fnHandler);
+}
+function instrumentSQLStorageExecBatch(fn, operation) {
+  const tracer = trace.getTracer("do_sql_storage");
+  const fnHandler = {
+    apply: (target, thisArg, argArray) => {
+      const statements = argArray[0];
+      const attributes = {
+        [ATTR_DB_SYSTEM_NAME]: dbSystem,
+        [ATTR_DB_OPERATION_NAME]: operation,
+        [ATTR_DB_OPERATION_BATCH_SIZE]: statements.length
+      };
+      if (statements.length > 0 && statements[0]) {
+        attributes[ATTR_DB_QUERY_TEXT] = statements[0].query;
+      }
+      const options = {
+        kind: SpanKind.CLIENT,
+        attributes
+      };
+      return tracer.startActiveSpan(`Durable Object SQL ${operation}`, options, async (span) => {
+        const results = await Reflect.apply(target, thisArg, argArray);
+        let totalRowsRead = 0;
+        let totalRowsWritten = 0;
+        for (const result of results) {
+          if (result && typeof result === "object") {
+            if ("rowsRead" in result) {
+              totalRowsRead += result.rowsRead;
+            }
+            if ("rowsWritten" in result) {
+              totalRowsWritten += result.rowsWritten;
+            }
+          }
+        }
+        span.setAttribute(ATTR_CLOUDFLARE_DO_SQL_RESPONSE_ROWS_READ, totalRowsRead);
+        span.setAttribute(ATTR_CLOUDFLARE_DO_SQL_RESPONSE_ROWS_WRITTEN, totalRowsWritten);
+        span.end();
+        return results;
+      });
+    }
+  };
+  return wrap(fn, fnHandler);
+}
+function instrumentSQLStorage(sql) {
+  const sqlHandler = {
+    get: (target, prop, receiver) => {
+      const fn = Reflect.get(target, prop, receiver);
+      if (typeof fn !== "function") {
+        return fn;
+      }
+      switch (prop) {
+        case "exec":
+          return instrumentSQLStorageExec(fn, "exec");
+        case "execBatch":
+          return instrumentSQLStorageExecBatch(fn, "execBatch");
+        default:
+          return fn;
+      }
+    }
+  };
+  return wrap(sql, sqlHandler);
+}
+
+function instrumentBindingStub(stub, nsName) {
+  const stubHandler = {
+    get(target, prop, receiver) {
+      if (prop === "fetch") {
+        const fetcher = Reflect.get(target, prop);
+        const attrs = {
+          name: `Durable Object ${nsName}`,
+          "do.namespace": nsName,
+          "do.id": target.id.toString(),
+          "do.id.name": target.id.name
+        };
+        return instrumentClientFetch(fetcher, () => ({ includeTraceContext: true }), attrs);
+      } else {
+        return passthroughGet(target, prop, receiver);
+      }
+    }
+  };
+  return wrap(stub, stubHandler);
+}
+function instrumentBindingGet(getFn, nsName) {
+  const getHandler = {
+    apply(target, thisArg, argArray) {
+      const stub = Reflect.apply(target, thisArg, argArray);
+      return instrumentBindingStub(stub, nsName);
+    }
+  };
+  return wrap(getFn, getHandler);
+}
+function instrumentDOBinding(ns, nsName) {
+  const nsHandler = {
+    get(target, prop, receiver) {
+      if (prop === "get") {
+        const fn = Reflect.get(ns, prop, receiver);
+        return instrumentBindingGet(fn, nsName);
+      } else {
+        return passthroughGet(target, prop, receiver);
+      }
+    }
+  };
+  return wrap(ns, nsHandler);
+}
+function instrumentState(state) {
+  const stateHandler = {
+    get(target, prop, receiver) {
+      const result = Reflect.get(target, prop, unwrap(receiver));
+      if (prop === "storage") {
+        return instrumentStorage(result);
+      } else if (typeof result === "function") {
+        return result.bind(target);
+      } else {
+        return result;
+      }
+    }
+  };
+  return wrap(state, stateHandler);
+}
+let cold_start$1 = true;
+function executeDOFetch(fetchFn, request, id) {
+  const spanContext = getParentContextFromHeaders(request.headers);
+  const tracer = trace.getTracer("DO fetchHandler");
+  const attributes = {
+    [SemanticAttributes.FAAS_TRIGGER]: "http",
+    [SemanticAttributes.FAAS_COLDSTART]: cold_start$1
+  };
+  cold_start$1 = false;
+  Object.assign(attributes, gatherRequestAttributes(request));
+  Object.assign(attributes, gatherIncomingCfAttributes(request));
+  const options = {
+    attributes,
+    kind: SpanKind.SERVER
+  };
+  const name = id.name || "";
+  const promise = tracer.startActiveSpan(`Durable Object Fetch ${name}`, options, spanContext, async (span) => {
+    try {
+      const response = await fetchFn(request);
+      if (response.ok) {
+        span.setStatus({ code: SpanStatusCode.OK });
+      }
+      span.setAttributes(gatherResponseAttributes(response));
+      span.end();
+      return response;
+    } catch (error) {
+      span.recordException(error);
+      span.setStatus({ code: SpanStatusCode.ERROR });
+      span.end();
+      throw error;
+    }
+  });
+  return promise;
+}
+function executeDOAlarm(alarmFn, id) {
+  const tracer = trace.getTracer("DO alarmHandler");
+  const name = id.name || "";
+  const promise = tracer.startActiveSpan(`Durable Object Alarm ${name}`, async (span) => {
+    span.setAttribute(SemanticAttributes.FAAS_COLDSTART, cold_start$1);
+    cold_start$1 = false;
+    span.setAttribute("do.id", id.toString());
+    if (id.name) span.setAttribute("do.name", id.name);
+    try {
+      await alarmFn();
+      span.end();
+    } catch (error) {
+      span.recordException(error);
+      span.setStatus({ code: SpanStatusCode.ERROR });
+      span.end();
+      throw error;
+    }
+  });
+  return promise;
+}
+function instrumentFetchFn(fetchFn, initialiser, env, id) {
+  const fetchHandler = {
+    async apply(target, thisArg, argArray) {
+      const request = argArray[0];
+      const config = initialiser(env, request);
+      const context$1 = setConfig(config);
+      try {
+        const bound = target.bind(unwrap(thisArg));
+        return await context.with(context$1, executeDOFetch, void 0, bound, request, id);
+      } catch (error) {
+        throw error;
+      }
+    }
+  };
+  return wrap(fetchFn, fetchHandler);
+}
+function instrumentAlarmFn(alarmFn, initialiser, env, id) {
+  if (!alarmFn) return void 0;
+  const alarmHandler = {
+    async apply(target, thisArg) {
+      const config = initialiser(env, "do-alarm");
+      const context$1 = setConfig(config);
+      try {
+        const bound = target.bind(unwrap(thisArg));
+        return await context.with(context$1, executeDOAlarm, void 0, bound, id);
+      } catch (error) {
+        throw error;
+      }
+    }
+  };
+  return wrap(alarmFn, alarmHandler);
+}
+function instrumentAnyFn(fn, initialiser, env, _id) {
+  if (!fn) return void 0;
+  const fnHandler = {
+    async apply(target, thisArg, argArray) {
+      thisArg = unwrap(thisArg);
+      const config = initialiser(env, "do-alarm");
+      const context$1 = setConfig(config);
+      try {
+        const bound = target.bind(unwrap(thisArg));
+        return await context.with(context$1, () => bound.apply(thisArg, argArray), void 0);
+      } catch (error) {
+        throw error;
+      }
+    }
+  };
+  return wrap(fn, fnHandler);
+}
+function instrumentDurableObject(doObj, initialiser, env, state, classStyle) {
+  const objHandler = {
+    get(target, prop) {
+      if (classStyle && prop === "ctx") {
+        return state;
+      } else if (classStyle && prop === "env") {
+        return env;
+      } else if (prop === "fetch") {
+        const fetchFn = Reflect.get(target, prop);
+        return instrumentFetchFn(fetchFn, initialiser, env, state.id);
+      } else if (prop === "alarm") {
+        const alarmFn = Reflect.get(target, prop);
+        return instrumentAlarmFn(alarmFn, initialiser, env, state.id);
+      } else {
+        const result = Reflect.get(target, prop);
+        if (typeof result === "function") {
+          result.bind(doObj);
+          return instrumentAnyFn(result, initialiser, env, state.id);
+        }
+        return result;
+      }
+    }
+  };
+  return wrap(doObj, objHandler);
+}
+function instrumentDOClass(doClass, initialiser) {
+  const classHandler = {
+    construct(target, [orig_state, orig_env]) {
+      const trigger = {
+        id: orig_state.id.toString(),
+        name: orig_state.id.name
+      };
+      const constructorConfig = initialiser(orig_env, trigger);
+      const context$1 = setConfig(constructorConfig);
+      const state = instrumentState(orig_state);
+      const env = instrumentEnv(orig_env);
+      const classStyle = doClass.prototype instanceof DurableObject;
+      const createDO = () => {
+        if (classStyle) {
+          return new target(orig_state, orig_env);
+        } else {
+          return new target(state, env);
+        }
+      };
+      const doObj = context.with(context$1, createDO);
+      return instrumentDurableObject(doObj, initialiser, env, state, classStyle);
+    }
+  };
+  return wrap(doClass, classHandler);
+}
+
+const scheduledInstrumentation = {
+  getInitialSpanInfo: function(controller) {
+    const scheduledTimeISO = new Date(controller.scheduledTime).toISOString();
+    return {
+      name: `scheduledHandler ${controller.cron}`,
+      options: {
+        attributes: {
+          [ATTR_FAAS_TRIGGER]: FAAS_TRIGGER_VALUE_TIMER,
+          [ATTR_FAAS_CRON]: controller.cron,
+          [ATTR_FAAS_TIME]: scheduledTimeISO,
+          [ATTR_CLOUDFLARE_SCHEDULED_TIME]: scheduledTimeISO
+        },
+        kind: SpanKind.INTERNAL
+      }
+    };
+  }
+};
+
+function versionAttributes(env) {
+  const attributes = {};
+  if (typeof env === "object" && env !== null) {
+    for (const [binding, data] of Object.entries(env)) {
+      if (isVersionMetadata(data)) {
+        attributes["cf.workers_version_metadata.binding"] = binding;
+        attributes["cf.workers_version_metadata.id"] = data.id;
+        attributes["cf.workers_version_metadata.tag"] = data.tag;
+        break;
+      }
+    }
+  }
+  return attributes;
+}
+
+class PromiseTracker {
+  _outstandingPromises = [];
+  get outstandingPromiseCount() {
+    return this._outstandingPromises.length;
+  }
+  track(promise) {
+    this._outstandingPromises.push(promise);
+  }
+  async wait() {
+    await allSettledMutable(this._outstandingPromises);
+  }
+}
+function createWaitUntil(fn, context, tracker) {
+  const handler = {
+    apply(target, _thisArg, argArray) {
+      tracker.track(argArray[0]);
+      return Reflect.apply(target, context, argArray);
+    }
+  };
+  return wrap(fn, handler);
+}
+function proxyExecutionContext(context) {
+  const tracker = new PromiseTracker();
+  const ctx = new Proxy(context, {
+    get(target, prop) {
+      if (prop === "waitUntil") {
+        const fn = Reflect.get(target, prop);
+        return createWaitUntil(fn, context, tracker);
+      } else {
+        return passthroughGet(target, prop);
+      }
+    }
+  });
+  return { ctx, tracker };
+}
+async function allSettledMutable(promises) {
+  let values;
+  do {
+    values = await Promise.allSettled(promises);
+  } while (values.length !== promises.length);
+  return values;
+}
+
+function headerAttributes(message) {
+  return Object.fromEntries([...message.headers].map(([key, value]) => [`email.header.${key}`, value]));
+}
+const emailInstrumentation = {
+  getInitialSpanInfo: (message) => {
+    const attributes = {
+      [ATTR_FAAS_TRIGGER]: "other",
+      [ATTR_RPC_MESSAGE_ID]: message.headers.get("Message-Id") ?? void 0,
+      [ATTR_MESSAGING_DESTINATION_NAME]: message.to,
+      [ATTR_CLOUDFLARE_EMAIL_FROM]: message.from,
+      [ATTR_CLOUDFLARE_EMAIL_TO]: message.to,
+      [ATTR_CLOUDFLARE_EMAIL_SIZE]: message.rawSize
+    };
+    Object.assign(attributes, headerAttributes(message));
+    const options = {
+      attributes,
+      kind: SpanKind.CONSUMER
+    };
+    return {
+      name: `emailHandler ${message.to}`,
+      options
+    };
+  }
+};
+
+function isRequest(trigger) {
+  return trigger instanceof Request;
+}
+function isMessageBatch(trigger) {
+  return !!trigger.ackAll;
+}
+function isAlarm(trigger) {
+  return trigger === "do-alarm";
+}
+function findVersionMeta() {
+  return Object.values(env).find((binding) => {
+    return Object.getPrototypeOf(binding).constructor.name === "Object" && binding.id !== void 0 && binding.tag !== void 0;
+  });
+}
+const createResource = (serviceConfig, versionMeta) => {
+  console.log({ versionMeta });
+  const workerResourceAttrs = {
+    "cloud.provider": "cloudflare",
+    "cloud.platform": "cloudflare.workers",
+    "cloud.region": "earth",
+    "faas.max_memory": 134217728,
+    "telemetry.sdk.language": "js",
+    "telemetry.sdk.name": "@inference-net/otel-cf-workers",
+    "telemetry.sdk.version": PACKAGE_VERSION,
+    "cf.worker.version.id": versionMeta?.id,
+    "cf.worker.version.tag": versionMeta?.tag,
+    "cf.worker.version.timestamp": versionMeta?.timestamp
+  };
+  const serviceResource = resourceFromAttributes({
+    "service.name": serviceConfig.name,
+    "service.namespace": serviceConfig.namespace,
+    "service.version": serviceConfig.version
+  });
+  const resource = resourceFromAttributes(workerResourceAttrs);
+  return resource.merge(serviceResource);
+};
+let initialised = false;
+function init(config, serviceConfig, propagator) {
+  if (!initialised) {
+    const resource = createResource(serviceConfig, findVersionMeta());
+    if (config.trace) {
+      if (config.trace.instrumentation.instrumentGlobalCache) {
+        instrumentGlobalCache();
+      }
+      if (config.trace.instrumentation.instrumentGlobalFetch) {
+        instrumentGlobalFetch();
+      }
+      const traceProvider = new WorkerTracerProvider(config.trace.spanProcessors, resource);
+      traceProvider.register();
+    }
+    if (config.logs && config.logs.processors.length > 0) {
+      const logsProvider = new WorkerLoggerProvider(config.logs.processors, resource);
+      logsProvider.register();
+      if (config.logs.instrumentation.instrumentConsole) {
+        import('./console-Cy5QdByD.js').then(({ instrumentConsole }) => {
+          instrumentConsole();
+        });
+      }
+    }
+    propagation.setGlobalPropagator(propagator);
+    initialised = true;
+  }
+}
+function createInitialiser(config) {
+  if (typeof config === "function") {
+    return (env2, trigger) => {
+      const userConfig = config(env2, trigger);
+      const conf = parseConfig(userConfig);
+      const propagator = userConfig.propagator || new W3CTraceContextPropagator();
+      init(conf, userConfig.service, propagator);
+      return conf;
+    };
+  } else {
+    return () => {
+      const conf = parseConfig(config);
+      const propagator = config.propagator || new W3CTraceContextPropagator();
+      init(conf, config.service, propagator);
+      return conf;
+    };
+  }
+}
+async function exportTelemetry(traceId, tracker) {
+  const tracer = trace.getTracer("export");
+  const { getLogger } = await Promise.resolve().then(() => provider);
+  const logger = getLogger("export");
+  if (tracer instanceof WorkerTracer) {
+    await scheduler.wait(1);
+    await tracker?.wait();
+    await tracer.forceFlush(traceId);
+  }
+  if (logger && typeof logger.forceFlush === "function") {
+    await logger.forceFlush();
+  }
+}
+const exportSpans = exportTelemetry;
+let cold_start = true;
+function createHandlerFlowFn(instrumentation) {
+  return (handlerFn, args) => {
+    const [trigger, env2, context$1] = args;
+    const proxiedEnv = instrumentEnv(env2);
+    const { ctx: proxiedCtx, tracker } = proxyExecutionContext(context$1);
+    const instrumentedTrigger = instrumentation.instrumentTrigger ? instrumentation.instrumentTrigger(trigger) : trigger;
+    const tracer = trace.getTracer("handler");
+    const { name, options, context: spanContext } = instrumentation.getInitialSpanInfo(trigger);
+    const attrs = options.attributes || {};
+    attrs["faas.coldstart"] = cold_start;
+    options.attributes = attrs;
+    Object.assign(attrs, versionAttributes(env2));
+    cold_start = false;
+    const parentContext = spanContext || context.active();
+    const result = tracer.startActiveSpan(name, options, parentContext, async (span) => {
+      try {
+        const result2 = await handlerFn(instrumentedTrigger, proxiedEnv, proxiedCtx);
+        if (instrumentation.getAttributesFromResult) {
+          const attributes = instrumentation.getAttributesFromResult(result2);
+          span.setAttributes(attributes);
+        }
+        if (instrumentation.executionSucces) {
+          instrumentation.executionSucces(span, trigger, result2);
+        }
+        return result2;
+      } catch (error) {
+        span.recordException(error);
+        span.setStatus({ code: SpanStatusCode.ERROR });
+        if (instrumentation.executionFailed) {
+          instrumentation.executionFailed(span, trigger, error);
+        }
+        throw error;
+      } finally {
+        span.end();
+        context$1.waitUntil(exportTelemetry(span.spanContext().traceId, tracker));
+      }
+    });
+    return result;
+  };
+}
+function createHandlerProxy(handler, handlerFn, initialiser, instrumentation) {
+  return (trigger, env2, ctx) => {
+    const config = initialiser(env2, trigger);
+    const context$1 = setConfig(config);
+    const flowFn = createHandlerFlowFn(instrumentation);
+    return context.with(context$1, flowFn, handler, handlerFn, [trigger, env2, ctx]);
+  };
+}
+function instrument(handler, config) {
+  const initialiser = createInitialiser(config);
+  if (handler.fetch) {
+    const fetcher = unwrap(handler.fetch);
+    handler.fetch = createHandlerProxy(handler, fetcher, initialiser, fetchInstrumentation);
+  }
+  if (handler.scheduled) {
+    const scheduler2 = unwrap(handler.scheduled);
+    handler.scheduled = createHandlerProxy(handler, scheduler2, initialiser, scheduledInstrumentation);
+  }
+  if (handler.queue) {
+    const queuer = unwrap(handler.queue);
+    handler.queue = createHandlerProxy(handler, queuer, initialiser, new QueueInstrumentation());
+  }
+  if (handler.email) {
+    const emailer = unwrap(handler.email);
+    handler.email = createHandlerProxy(handler, emailer, initialiser, emailInstrumentation);
+  }
+  return handler;
+}
+function instrumentDO(doClass, config) {
+  const initialiser = createInitialiser(config);
+  return instrumentDOClass(doClass, initialiser);
+}
+const __unwrappedFetch = unwrap(fetch);
+
+class MultiSpanExporter {
+  exporters;
+  constructor(exporters) {
+    this.exporters = exporters;
+  }
+  export(items, resultCallback) {
+    for (const exporter of this.exporters) {
+      exporter.export(items, resultCallback);
+    }
+  }
+  async shutdown() {
+    for (const exporter of this.exporters) {
+      await exporter.shutdown();
+    }
+  }
+}
+class MultiSpanExporterAsync {
+  exporters;
+  constructor(exporters) {
+    this.exporters = exporters;
+  }
+  export(items, resultCallback) {
+    const promises = this.exporters.map(
+      (exporter) => new Promise((resolve) => {
+        exporter.export(items, resolve);
+      })
+    );
+    Promise.all(promises).then((results) => {
+      const failed = results.filter((result) => result.code === ExportResultCode.FAILED);
+      if (failed.length > 0) {
+        resultCallback({ code: ExportResultCode.FAILED, error: failed[0].error });
+      } else {
+        resultCallback({ code: ExportResultCode.SUCCESS });
+      }
+    });
+  }
+  async shutdown() {
+    await Promise.all(this.exporters.map((exporter) => exporter.shutdown()));
+  }
+}
+
+class OTLPTransport {
+  name = "otlp";
+  headers;
+  url;
+  constructor(config) {
+    this.url = config.url;
+    this.headers = Object.assign({}, DEFAULT_OTLP_HEADERS, config.headers);
+  }
+  export(logs, callback) {
+    this._export(logs).then(() => {
+      callback({ code: ExportResultCode.SUCCESS });
+    }).catch((error) => {
+      callback({ code: ExportResultCode.FAILED, error });
+    });
+  }
+  async _export(logs) {
+    try {
+      await this.send(logs);
+    } catch (e) {
+      throw e;
+    }
+  }
+  async send(logs) {
+    const otlpLogs = this.transformToOTLP(logs);
+    const body = JSON.stringify(otlpLogs);
+    const params = {
+      method: "POST",
+      headers: this.headers,
+      body
+    };
+    const response = await unwrap(fetch)(this.url, params);
+    if (!response.ok) {
+      throw new OTLPExporterError(`Exporter received a statusCode: ${response.status}`);
+    }
+  }
+  transformToOTLP(logs) {
+    const resourceLogsMap = /* @__PURE__ */ new Map();
+    for (const log of logs) {
+      const resourceKey = JSON.stringify(log.resource.attributes);
+      const scopeKey = JSON.stringify(log.instrumentationScope);
+      if (!resourceLogsMap.has(resourceKey)) {
+        resourceLogsMap.set(resourceKey, /* @__PURE__ */ new Map());
+      }
+      const scopeLogsMap = resourceLogsMap.get(resourceKey);
+      if (!scopeLogsMap.has(scopeKey)) {
+        scopeLogsMap.set(scopeKey, []);
+      }
+      scopeLogsMap.get(scopeKey).push(log);
+    }
+    const resourceLogs = [];
+    for (const [resourceKey, scopeLogsMap] of resourceLogsMap) {
+      const resource = logs.find((l) => JSON.stringify(l.resource.attributes) === resourceKey).resource;
+      const scopeLogs = [];
+      for (const [_scopeKey, scopeRecords] of scopeLogsMap) {
+        const scope = scopeRecords[0].instrumentationScope;
+        scopeLogs.push({
+          scope: {
+            name: scope.name,
+            version: scope.version
+          },
+          logRecords: scopeRecords.map((log) => this.transformLogRecord(log))
+        });
+      }
+      resourceLogs.push({
+        resource: {
+          attributes: this.transformAttributes(resource.attributes)
+        },
+        scopeLogs
+      });
+    }
+    return { resourceLogs };
+  }
+  transformLogRecord(log) {
+    const record = {
+      timeUnixNano: this.hrTimeToString(log.timeUnixNano),
+      observedTimeUnixNano: this.hrTimeToString(log.observedTimeUnixNano),
+      severityNumber: log.severityNumber,
+      severityText: log.severityText,
+      body: this.transformBody(log.body),
+      attributes: this.transformAttributes(log.attributes),
+      droppedAttributesCount: log.droppedAttributesCount || 0
+    };
+    if (log.traceId) {
+      record.traceId = log.traceId;
+    }
+    if (log.spanId) {
+      record.spanId = log.spanId;
+    }
+    if (log.traceFlags !== void 0) {
+      record.flags = log.traceFlags;
+    }
+    return record;
+  }
+  transformBody(body) {
+    if (body === void 0 || body === null) {
+      return void 0;
+    }
+    if (typeof body === "string") {
+      return { stringValue: body };
+    }
+    return { stringValue: JSON.stringify(body) };
+  }
+  transformAttributes(attrs) {
+    return Object.entries(attrs).map(([key, value]) => ({
+      key,
+      value: this.transformAttributeValue(value)
+    }));
+  }
+  transformAttributeValue(value) {
+    if (typeof value === "string") {
+      return { stringValue: value };
+    } else if (typeof value === "number") {
+      if (Number.isInteger(value)) {
+        return { intValue: value.toString() };
+      }
+      return { doubleValue: value };
+    } else if (typeof value === "boolean") {
+      return { boolValue: value };
+    } else if (Array.isArray(value)) {
+      return {
+        arrayValue: {
+          values: value.map((v) => this.transformAttributeValue(v))
+        }
+      };
+    }
+    return { stringValue: String(value) };
+  }
+  hrTimeToString(hrTime) {
+    const nanos = BigInt(hrTime[0]) * BigInt(1e9) + BigInt(hrTime[1]);
+    return nanos.toString();
+  }
+  async shutdown() {
+  }
+}
+class ConsoleTransport {
+  name = "console";
+  options;
+  constructor(options = {}) {
+    this.options = {
+      pretty: options.pretty ?? true,
+      colors: options.colors ?? false,
+      includeTimestamp: options.includeTimestamp ?? true
+    };
+  }
+  export(logs, callback) {
+    try {
+      for (const log of logs) {
+        this.printLog(log);
+      }
+      callback({ code: ExportResultCode.SUCCESS });
+    } catch (error) {
+      callback({ code: ExportResultCode.FAILED, error });
+    }
+  }
+  printLog(log) {
+    if (this.options.pretty) {
+      this.prettyPrint(log);
+    } else {
+      console.log(JSON.stringify(this.serializeLog(log)));
+    }
+  }
+  prettyPrint(log) {
+    const parts = [];
+    if (this.options.includeTimestamp) {
+      const timestamp = new Date(log.timeUnixNano[0] * 1e3).toISOString();
+      parts.push(`[${timestamp}]`);
+    }
+    const severity = log.severityText || this.getSeverityText(log.severityNumber);
+    parts.push(severity.padEnd(5));
+    if (log.traceId) {
+      parts.push(`[trace: ${log.traceId.substring(0, 16)}...]`);
+    }
+    const body = typeof log.body === "string" ? log.body : JSON.stringify(log.body);
+    parts.push(body);
+    const message = parts.join(" ");
+    switch (severity) {
+      case "TRACE":
+      case "DEBUG":
+        console.debug(message, log.attributes);
+        break;
+      case "INFO":
+        console.info(message, log.attributes);
+        break;
+      case "WARN":
+        console.warn(message, log.attributes);
+        break;
+      case "ERROR":
+      case "FATAL":
+        console.error(message, log.attributes);
+        break;
+      default:
+        console.log(message, log.attributes);
+    }
+  }
+  serializeLog(log) {
+    return {
+      timestamp: new Date(log.timeUnixNano[0] * 1e3).toISOString(),
+      severity: log.severityText || this.getSeverityText(log.severityNumber),
+      body: log.body,
+      attributes: log.attributes,
+      traceId: log.traceId,
+      spanId: log.spanId,
+      resource: log.resource.attributes,
+      scope: log.instrumentationScope
+    };
+  }
+  getSeverityText(severityNumber) {
+    if (!severityNumber) return "INFO";
+    if (severityNumber <= 4) return "TRACE";
+    if (severityNumber <= 8) return "DEBUG";
+    if (severityNumber <= 12) return "INFO";
+    if (severityNumber <= 16) return "WARN";
+    if (severityNumber <= 20) return "ERROR";
+    return "FATAL";
+  }
+  async shutdown() {
+  }
+}
+
+export { BatchSizeLogRecordProcessor, BatchTraceSpanProcessor, ConsoleTransport, ImmediateLogRecordProcessor, MultiSpanExporter, MultiSpanExporterAsync, MultiTransportLogRecordProcessor, OTLPExporter, OTLPTransport, SEVERITY_NUMBERS, SpanImpl, WorkerLogger, WorkerLoggerProvider, __unwrappedFetch, createLogProcessor, createSampler, exportSpans, exportTelemetry, getGlobalLoggerProvider, getLogger, instrument, instrumentDO, isAlarm, isHeadSampled, isMessageBatch, isRequest, isRootErrorSpan, multiTailSampler, setGlobalLoggerProvider, withNextSpan };
+//# sourceMappingURL=index.js.map