@kabyeon/nexusjs 0.6.5

package/dist/tracing/index.js

@@ -0,0 +1,782 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/core/constants.ts
+var METADATA_KEY, PARAM_TYPES, HTTP_METHODS;
+var init_constants = __esm(() => {
+  METADATA_KEY = {
+    CONTROLLER: "nexus:controller",
+    INJECTABLE: "nexus:injectable",
+    REPOSITORY: "nexus:repository",
+    MODULE: "nexus:module",
+    ROUTES: "nexus:routes",
+    PARAMS: "nexus:params",
+    VALIDATE: "nexus:validate",
+    PARAMTYPES: "design:paramtypes",
+    TYPE: "design:type",
+    RETURNTYPE: "design:returntype",
+    INJECT: "nexus:inject"
+  };
+  PARAM_TYPES = {
+    REQUEST: 0,
+    RESPONSE: 1,
+    NEXT: 2,
+    BODY: 3,
+    QUERY: 4,
+    PARAM: 5,
+    HEADERS: 6,
+    CTX: 7,
+    USER: 8
+  };
+  HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+});
+
+// src/core/decorators/controller.ts
+import"reflect-metadata";
+function Controller(prefix = "/") {
+  return (target) => {
+    const normalized = normalizePrefix(prefix);
+    const meta = { prefix: normalized };
+    Reflect.defineMetadata(METADATA_KEY.CONTROLLER, meta, target);
+  };
+}
+function getControllerMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.CONTROLLER, target) ?? { prefix: "/" };
+}
+function isController(target) {
+  return Reflect.hasMetadata(METADATA_KEY.CONTROLLER, target);
+}
+function normalizePrefix(prefix) {
+  if (!prefix)
+    return "";
+  if (prefix !== "/" && prefix.endsWith("/")) {
+    return prefix.slice(0, -1);
+  }
+  return prefix;
+}
+var init_controller = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/http-methods.ts
+import"reflect-metadata";
+function defineRoute(method, path) {
+  return (target, propertyKey, descriptor) => {
+    const routes = Reflect.getMetadata(METADATA_KEY.ROUTES, target.constructor) ?? [];
+    routes.push({
+      method,
+      path: normalizePath(path),
+      propertyKey,
+      handler: descriptor.value
+    });
+    Reflect.defineMetadata(METADATA_KEY.ROUTES, routes, target.constructor);
+  };
+}
+function normalizePath(path) {
+  if (!path || path === "/")
+    return "/";
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function getRoutes(target) {
+  return Reflect.getMetadata(METADATA_KEY.ROUTES, target) ?? [];
+}
+var Get = (path = "/") => defineRoute("GET", path), Post = (path = "/") => defineRoute("POST", path), Put = (path = "/") => defineRoute("PUT", path), Delete = (path = "/") => defineRoute("DELETE", path), Patch = (path = "/") => defineRoute("PATCH", path), Options = (path = "/") => defineRoute("OPTIONS", path), Head = (path = "/") => defineRoute("HEAD", path);
+var init_http_methods = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/params.ts
+import"reflect-metadata";
+function createParamDecorator(type, data) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target, propertyKey);
+    } else {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target);
+    }
+  };
+}
+function getParamMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+}
+var Req = () => createParamDecorator(PARAM_TYPES.REQUEST), Res = () => createParamDecorator(PARAM_TYPES.RESPONSE), Next = () => createParamDecorator(PARAM_TYPES.NEXT), Body = (key) => createParamDecorator(PARAM_TYPES.BODY, key), Query = (key) => createParamDecorator(PARAM_TYPES.QUERY, key), Param = (key) => createParamDecorator(PARAM_TYPES.PARAM, key), Headers = (key) => createParamDecorator(PARAM_TYPES.HEADERS, key), Ctx = () => createParamDecorator(PARAM_TYPES.CTX), User = () => createParamDecorator(PARAM_TYPES.USER);
+var init_params = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/validate.ts
+import"reflect-metadata";
+function Validate(options) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(METADATA_KEY.VALIDATE, options, target.constructor, propertyKey);
+  };
+}
+function getValidationMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.VALIDATE, target, propertyKey);
+}
+var init_validate = __esm(() => {
+  init_constants();
+});
+
+// src/tracing/service.ts
+import {
+  context as otelContext,
+  propagation,
+  SpanStatusCode,
+  SpanKind,
+  trace
+} from "@opentelemetry/api";
+
+class InMemorySpanRecorder {
+  finished = [];
+  nextEventCounter = 0;
+  record(span) {
+    this.finished.push(span);
+    this.nextEventCounter++;
+  }
+  getAll() {
+    return this.finished;
+  }
+  findByName(name) {
+    return this.finished.filter((s) => s.name === name);
+  }
+  clear() {
+    this.finished = [];
+    this.nextEventCounter = 0;
+  }
+  get size() {
+    return this.finished.length;
+  }
+}
+
+class OtelActiveSpan {
+  name;
+  traceId;
+  spanId;
+  isRecording;
+  otelSpan;
+  constructor(name, traceId, spanId, isRecording, otelSpan) {
+    this.name = name;
+    this.traceId = traceId;
+    this.spanId = spanId;
+    this.isRecording = isRecording;
+    this.otelSpan = otelSpan;
+  }
+  setAttribute(key, value) {
+    this.otelSpan.setAttribute(key, value);
+  }
+  setAttributes(attributes) {
+    this.otelSpan.setAttributes(attributes);
+  }
+  addEvent(name, attributes) {
+    this.otelSpan.addEvent(name, attributes);
+  }
+  recordException(err) {
+    if (err instanceof Error) {
+      this.otelSpan.recordException(err);
+    } else {
+      this.otelSpan.recordException(new Error(String(err)));
+    }
+  }
+  setStatus(status, description) {
+    const code = status === "ok" ? SpanStatusCode.OK : status === "error" ? SpanStatusCode.ERROR : SpanStatusCode.UNSET;
+    this.otelSpan.setStatus({ code, message: description });
+  }
+  end() {
+    this.otelSpan.end();
+  }
+}
+var TRACING_SERVICE_TOKEN = Symbol.for("nexus:TracingService");
+var _current;
+function setTracingService(service) {
+  _current = service;
+}
+function getTracingService() {
+  return _current;
+}
+
+class TracingService {
+  tracer;
+  recorder = new InMemorySpanRecorder;
+  sdkStop;
+  initialized = false;
+  constructor() {
+    this.tracer = trace.getTracer("nexusjs", "0.4.0");
+  }
+  get isInitialized() {
+    return this.initialized;
+  }
+  getSpans() {
+    return this.recorder.getAll();
+  }
+  findSpans(name) {
+    return this.recorder.findByName(name);
+  }
+  clearSpans() {
+    this.recorder.clear();
+  }
+  startSpan(name, options = {}) {
+    const kind = toOtelKind(options.kind ?? "internal");
+    const otelSpan = this.tracer.startSpan(name, {
+      kind,
+      attributes: options.attributes,
+      startTime: options.startTime
+    });
+    const ctx = otelSpan.spanContext();
+    return new OtelActiveSpan(name, ctx.traceId, ctx.spanId, otelSpan.isRecording(), otelSpan);
+  }
+  async withSpan(name, fn, options = {}) {
+    const span = this.startSpan(name, options);
+    const ctx = trace.setSpan(otelContext.active(), span["otelSpan"]);
+    try {
+      const result = await otelContext.with(ctx, () => fn(span));
+      if (span.isRecording)
+        span.setStatus("ok");
+      return result;
+    } catch (err) {
+      if (span.isRecording) {
+        span.recordException(err);
+        span.setStatus("error", err instanceof Error ? err.message : String(err));
+      }
+      throw err;
+    } finally {
+      span.end();
+    }
+  }
+  withSpanSync(name, fn, options = {}) {
+    const span = this.startSpan(name, options);
+    try {
+      const result = fn(span);
+      if (span.isRecording)
+        span.setStatus("ok");
+      return result;
+    } catch (err) {
+      if (span.isRecording) {
+        span.recordException(err);
+        span.setStatus("error", err instanceof Error ? err.message : String(err));
+      }
+      throw err;
+    } finally {
+      span.end();
+    }
+  }
+  getCurrentTraceId() {
+    const ctx = trace.getSpan(otelContext.active())?.spanContext();
+    return ctx?.traceId;
+  }
+  getCurrentSpanId() {
+    const ctx = trace.getSpan(otelContext.active())?.spanContext();
+    return ctx?.spanId;
+  }
+  getCurrentContext() {
+    return otelContext.active();
+  }
+  extractContext(headers) {
+    const flat = flattenHeaders(headers);
+    return propagation.extract(otelContext.active(), flat);
+  }
+  injectContext(headers = {}) {
+    const out = { ...headers };
+    propagation.inject(otelContext.active(), out);
+    return out;
+  }
+  async startSdk(config) {
+    if (this.initialized)
+      return;
+    const serviceName = config.serviceName ?? process.env.OTEL_SERVICE_NAME ?? "nexusjs";
+    const endpoint = config.endpoint ?? process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://localhost:4318";
+    const sampleRatio = config.sampleRatio ?? 1;
+    let NodeSDK, OTLPTraceExporter, Resource, SemanticResourceAttributes;
+    try {
+      ({ NodeSDK } = await import("@opentelemetry/sdk-node"));
+      ({ OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-http"));
+      ({ Resource } = await import("@opentelemetry/resources"));
+      const semconv = await import("@opentelemetry/semantic-conventions");
+      SemanticResourceAttributes = semconv.SemanticResourceAttributes ?? semconv;
+    } catch (err) {
+      throw new Error("TracingModule.forRoot() requires the OTel SDK packages. Install with: bun add @opentelemetry/sdk-node @opentelemetry/exporter-trace-otlp-http @opentelemetry/resources @opentelemetry/semantic-conventions");
+    }
+    const resourceAttrs = {
+      [SemanticResourceAttributes.SERVICE_NAME ?? "service.name"]: serviceName,
+      [SemanticResourceAttributes.SERVICE_VERSION ?? "service.version"]: config.serviceVersion ?? "0.0.0",
+      [SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT ?? "deployment.environment"]: config.environment ?? "development" ?? "development",
+      ...config.resourceAttributes
+    };
+    const resource = new Resource(resourceAttrs);
+    let traceExporter;
+    if (config.exporter === "console" || config.exporter === "memory" || !config.exporter) {
+      traceExporter = undefined;
+    } else {
+      traceExporter = new OTLPTraceExporter({ url: `${endpoint.replace(/\/$/, "")}/v1/traces` });
+    }
+    const sdk = new NodeSDK({
+      resource,
+      traceExporter,
+      sampler: {
+        shouldSample: () => ({
+          decision: Math.random() < sampleRatio ? 1 : 0
+        }),
+        toString: () => `RatioSampler(${sampleRatio})`
+      }
+    });
+    sdk.start();
+    this.sdkStop = async () => {
+      try {
+        await sdk.shutdown();
+      } catch {}
+    };
+    this.initialized = true;
+  }
+  async stopSdk() {
+    if (this.sdkStop) {
+      await this.sdkStop();
+      this.sdkStop = undefined;
+    }
+    this.initialized = false;
+  }
+}
+function toOtelKind(kind) {
+  switch (kind) {
+    case "server":
+      return SpanKind.SERVER;
+    case "client":
+      return SpanKind.CLIENT;
+    case "producer":
+      return SpanKind.PRODUCER;
+    case "consumer":
+      return SpanKind.CONSUMER;
+    default:
+      return SpanKind.INTERNAL;
+  }
+}
+function flattenHeaders(headers) {
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    if (v === undefined)
+      continue;
+    out[k.toLowerCase()] = Array.isArray(v) ? v.join(",") : v;
+  }
+  return out;
+}
+// src/core/decorators/module.ts
+init_constants();
+import"reflect-metadata";
+function Module(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.MODULE, options, target);
+  };
+}
+function getModuleOptions(target) {
+  return Reflect.getMetadata(METADATA_KEY.MODULE, target) ?? {};
+}
+
+// src/core/decorators/index.ts
+init_controller();
+
+// src/core/decorators/injectable.ts
+init_constants();
+import"reflect-metadata";
+function Injectable(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+    if (options.scope) {
+      Reflect.defineMetadata("nexus:di:scope", options.scope, target);
+    }
+  };
+}
+function isInjectable(target) {
+  return Reflect.hasMetadata(METADATA_KEY.INJECTABLE, target);
+}
+function getScope(target) {
+  return Reflect.getMetadata("nexus:di:scope", target);
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(METADATA_KEY.INJECT, target) ?? new Map;
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(METADATA_KEY.INJECT, existing, target);
+  };
+}
+
+// src/core/decorators/index.ts
+init_http_methods();
+init_params();
+init_validate();
+
+// src/core/decorators/repository.ts
+init_constants();
+import"reflect-metadata";
+function Repository(entityToken) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.REPOSITORY, { entity: entityToken }, target);
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+  };
+}
+function getRepositoryMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.REPOSITORY, target);
+}
+function isRepository(target) {
+  return Reflect.hasMetadata(METADATA_KEY.REPOSITORY, target);
+}
+// src/core/decorators/metadata.ts
+init_constants();
+// src/tracing/hono-instrumentation.ts
+import { SpanKind as SpanKind2, SpanStatusCode as SpanStatusCode2, trace as trace2 } from "@opentelemetry/api";
+function tracingMiddleware(service) {
+  return async (c, next) => {
+    const incoming = c.req.raw.headers;
+    const flat = {};
+    incoming.forEach((v, k) => flat[k] = v);
+    const extractedCtx = service.extractContext(flat);
+    const method = c.req.method;
+    const path = c.req.path;
+    const route = c.req.routePath ?? path;
+    const userAgent = c.req.header("user-agent") ?? "";
+    const url = new URL(c.req.url);
+    const clientIp = c.req.header("x-forwarded-for") ?? c.req.header("x-real-ip") ?? "";
+    const span = service.tracer.startSpan(`HTTP ${method} ${route}`, {
+      kind: SpanKind2.SERVER,
+      attributes: {
+        "http.method": method,
+        "http.target": path,
+        "http.route": route,
+        "http.scheme": url.protocol.replace(":", ""),
+        "http.host": url.host,
+        "http.user_agent": userAgent,
+        "http.client_ip": clientIp,
+        "url.path": path
+      }
+    }, extractedCtx);
+    const ctxWithSpan = trace2.setSpan(extractedCtx, span);
+    const result = await service.tracer.startActiveSpan(`HTTP ${method} ${route} handler`, { kind: SpanKind2.SERVER }, ctxWithSpan, async () => {
+      try {
+        await next();
+        const status = c.res.status;
+        span.setAttribute("http.status_code", status);
+        if (status >= 500) {
+          span.setStatus({ code: SpanStatusCode2.ERROR });
+        } else {
+          span.setStatus({ code: SpanStatusCode2.OK });
+        }
+      } catch (err) {
+        span.recordException(err);
+        span.setStatus({ code: SpanStatusCode2.ERROR, message: err.message });
+        span.setAttribute("http.status_code", 500);
+        throw err;
+      } finally {
+        span.end();
+      }
+    });
+    return result;
+  };
+}
+function injectOutgoingTraceparent(service, headers = {}) {
+  return service.injectContext(headers);
+}
+
+// src/tracing/module.ts
+var TRACING_CONFIG_TOKEN = Symbol.for("nexus:TracingConfig");
+
+class TracingConfigHolder {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+}
+TracingConfigHolder = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(TRACING_CONFIG_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Required === "undefined" ? Object : Required
+  ])
+], TracingConfigHolder);
+
+class TracingServiceWithLifecycle extends TracingService {
+  async onApplicationBootstrap() {}
+  async onApplicationShutdown() {
+    await this.stopSdk();
+  }
+}
+TracingServiceWithLifecycle = __legacyDecorateClassTS([
+  Injectable()
+], TracingServiceWithLifecycle);
+
+class TracingModule {
+  static forRoot(config = {}) {
+    const fullConfig = {
+      serviceName: config.serviceName ?? process.env.OTEL_SERVICE_NAME ?? "nexusjs",
+      serviceVersion: config.serviceVersion ?? "0.0.0",
+      environment: config.environment ?? "development" ?? "development",
+      exporter: config.exporter ?? "otlp-http",
+      endpoint: config.endpoint ?? process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://localhost:4318",
+      sampleRatio: config.sampleRatio ?? 1,
+      enableHttpInstrumentation: config.enableHttpInstrumentation ?? true,
+      enableDbInstrumentation: config.enableDbInstrumentation ?? true,
+      resourceAttributes: config.resourceAttributes ?? {},
+      throwOnError: config.throwOnError ?? false
+    };
+
+    class ConfiguredTracingModule {
+      svc;
+      constructor(svc) {
+        this.svc = svc;
+        svc.startSdk(fullConfig);
+        setTracingService(svc);
+      }
+    }
+    ConfiguredTracingModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          TracingServiceWithLifecycle,
+          { provide: TRACING_CONFIG_TOKEN, useValue: fullConfig },
+          { provide: TRACING_SERVICE_TOKEN, useExisting: TracingServiceWithLifecycle }
+        ],
+        exports: [TracingServiceWithLifecycle, TRACING_CONFIG_TOKEN, TRACING_SERVICE_TOKEN]
+      }),
+      __legacyDecorateParamTS(0, Inject(TracingServiceWithLifecycle)),
+      __legacyMetadataTS("design:paramtypes", [
+        typeof TracingServiceWithLifecycle === "undefined" ? Object : TracingServiceWithLifecycle
+      ])
+    ], ConfiguredTracingModule);
+    Object.defineProperty(ConfiguredTracingModule, "name", { value: "ConfiguredTracingModule" });
+    const mod = ConfiguredTracingModule;
+    mod.middleware = () => {
+      const svc = new TracingService;
+      setTracingService(svc);
+      return tracingMiddleware(svc);
+    };
+    return mod;
+  }
+}
+TracingModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      TracingServiceWithLifecycle,
+      { provide: TRACING_SERVICE_TOKEN, useExisting: TracingServiceWithLifecycle }
+    ],
+    exports: [TracingServiceWithLifecycle, TRACING_SERVICE_TOKEN]
+  })
+], TracingModule);
+// src/tracing/propagation.ts
+import { propagation as propagation2, context } from "@opentelemetry/api";
+var TRACE_PARENT_HEADER = "traceparent";
+var TRACE_STATE_HEADER = "tracestate";
+var B3_TRACE_ID_HEADER = "x-b3-traceid";
+var B3_SPAN_ID_HEADER = "x-b3-spanid";
+var B3_SAMPLED_HEADER = "x-b3-sampled";
+function parseTraceParent(value) {
+  if (!value)
+    return;
+  const parts = value.trim().split("-");
+  if (parts.length !== 4)
+    return;
+  const [version, traceId, parentSpanId, flags] = parts;
+  if (!/^[0-9a-f]{2}$/i.test(version))
+    return;
+  if (!/^[0-9a-f]{32}$/i.test(traceId))
+    return;
+  if (traceId === "0".repeat(32))
+    return;
+  if (!/^[0-9a-f]{16}$/i.test(parentSpanId))
+    return;
+  if (parentSpanId === "0".repeat(16))
+    return;
+  if (!/^[0-9a-f]{2}$/i.test(flags))
+    return;
+  return {
+    version,
+    traceId: traceId.toLowerCase(),
+    parentSpanId: parentSpanId.toLowerCase(),
+    flags: flags.toLowerCase(),
+    sampled: (parseInt(flags, 16) & 1) === 1
+  };
+}
+function formatTraceParent(traceId, spanId, sampled = true) {
+  const flags = sampled ? "01" : "00";
+  return `00-${traceId.toLowerCase()}-${spanId.toLowerCase()}-${flags}`;
+}
+function extractB3Context(headers) {
+  const b3 = headers["b3"] ?? headers["x-b3-traceid"];
+  if (!b3)
+    return;
+  if (b3.includes("-")) {
+    const [traceId, spanId, sampled] = b3.split("-");
+    if (traceId && spanId) {
+      return { traceId, spanId, sampled: sampled === "1" };
+    }
+  } else {
+    const spanId = headers["x-b3-spanid"];
+    const sampled = headers["x-b3-sampled"] === "1";
+    if (spanId)
+      return { traceId: b3, spanId, sampled };
+  }
+  return;
+}
+function inject(headers) {
+  const out = { ...headers };
+  propagation2.inject(context.active(), out);
+  return out;
+}
+function extract(headers) {
+  return propagation2.extract(context.active(), headers);
+}
+// src/tracing/decorators/trace.ts
+var TRACE_KEY = Symbol.for("nexus:trace:options");
+function Trace(opts) {
+  return function(target, propertyKey, descriptor) {
+    const original = descriptor.value;
+    if (typeof original !== "function") {
+      throw new Error(`@Trace() can only be applied to methods, got ${typeof original}`);
+    }
+    const options = normalizeOptions(opts ?? {}, target, propertyKey);
+    target[TRACE_KEY] = target[TRACE_KEY] ?? {};
+    target[TRACE_KEY][String(propertyKey)] = options;
+    const isAsync = original.constructor?.name === "AsyncFunction";
+    if (isAsync) {
+      descriptor.value = async function wrapped(...args) {
+        const service = getTracingService();
+        if (!service)
+          return original.apply(this, args);
+        return service.withSpan(options.name, async (span) => {
+          if (options.attributes)
+            span.setAttributes(options.attributes);
+          return original.apply(this, args);
+        }, { kind: options.kind ?? "internal", attributes: options.attributes });
+      };
+    } else {
+      descriptor.value = function wrapped(...args) {
+        const service = getTracingService();
+        if (!service)
+          return original.apply(this, args);
+        return service.withSpanSync(options.name, (span) => {
+          if (options.attributes)
+            span.setAttributes(options.attributes);
+          return original.apply(this, args);
+        }, { kind: options.kind ?? "internal", attributes: options.attributes });
+      };
+    }
+    return descriptor;
+  };
+}
+function getTraceOptions(target, method) {
+  return target[TRACE_KEY]?.[method];
+}
+function normalizeOptions(opts, target, propertyKey) {
+  if (typeof opts === "string") {
+    return { name: opts, kind: "internal" };
+  }
+  if (opts && typeof opts === "object" && "name" in opts && opts.name) {
+    const o = opts;
+    return {
+      name: o.name,
+      kind: o.kind ?? "internal",
+      attributes: o.attributes
+    };
+  }
+  const cls = target?.constructor?.name ?? "Anonymous";
+  return {
+    name: `${cls}.${String(propertyKey)}`,
+    kind: "internal"
+  };
+}
+export {
+  tracingMiddleware,
+  setTracingService,
+  parseTraceParent,
+  injectOutgoingTraceparent,
+  inject as injectContextHeaders,
+  getTracingService,
+  getTraceOptions,
+  formatTraceParent,
+  extract as extractContextHeaders,
+  extractB3Context,
+  TracingService,
+  TracingModule,
+  Trace,
+  TRACING_SERVICE_TOKEN,
+  TRACING_CONFIG_TOKEN,
+  TRACE_STATE_HEADER,
+  TRACE_PARENT_HEADER,
+  InMemorySpanRecorder,
+  B3_TRACE_ID_HEADER,
+  B3_SPAN_ID_HEADER,
+  B3_SAMPLED_HEADER
+};
+
+//# debugId=F843FD61ED743D5964756E2164756E21
+//# sourceMappingURL=index.js.map