@burdenoff/be-sdk 2026.510.79

package/dist/chunk-4XAEES25.js

@@ -0,0 +1,2444 @@
+import { logger } from './chunk-CBZNP6RF.js';
+import { __export, __name } from './chunk-XE4OXN2W.js';
+import { createRequire } from 'module';
+
+// src/instrumentation/index.ts
+var instrumentation_exports = {};
+__export(instrumentation_exports, {
+  DEFAULT_CACHE_CONFIG: () => DEFAULT_CACHE_CONFIG,
+  DEFAULT_DATABASE_CONFIG: () => DEFAULT_DATABASE_CONFIG,
+  DEFAULT_EVENT_QUEUE_CONFIG: () => DEFAULT_EVENT_QUEUE_CONFIG,
+  DEFAULT_FEATURE_FLAGS: () => DEFAULT_FEATURE_FLAGS,
+  DEFAULT_GRAPHQL_CONFIG: () => DEFAULT_GRAPHQL_CONFIG,
+  DEFAULT_HTTP_CONFIG: () => DEFAULT_HTTP_CONFIG,
+  DEFAULT_LOGGING_CONFIG: () => DEFAULT_LOGGING_CONFIG,
+  DEFAULT_METRICS_CONFIG: () => DEFAULT_METRICS_CONFIG,
+  DEFAULT_TRACING_CONFIG: () => DEFAULT_TRACING_CONFIG,
+  ENV_VARS: () => ENV_VARS,
+  Instrument: () => Instrument,
+  Log: () => Log,
+  Metric: () => Metric,
+  MetricsRegistry: () => MetricsRegistry,
+  STANDARD_METRICS: () => STANDARD_METRICS,
+  SpanKind: () => SpanKind,
+  SpanStatus: () => SpanStatus,
+  Trace: () => Trace,
+  Tracer: () => Tracer,
+  buildDatabaseConfig: () => buildDatabaseConfig,
+  buildFeatureFlags: () => buildFeatureFlags,
+  buildGraphQLConfig: () => buildGraphQLConfig,
+  buildInstrumentationConfig: () => buildInstrumentationConfig,
+  buildMetricsConfig: () => buildMetricsConfig,
+  buildTracingConfig: () => buildTracingConfig,
+  createApolloInlineTracePlugin: () => createApolloInlineTracePlugin,
+  createCounter: () => createCounter,
+  createGauge: () => createGauge,
+  createGraphQLInstrumentationPlugin: () => createGraphQLInstrumentationPlugin,
+  createHistogram: () => createHistogram,
+  createPrometheusPlugin: () => createPrometheusPlugin,
+  createUpDownCounter: () => createUpDownCounter,
+  extractOperationInfo: () => extractOperationInfo,
+  extractTraceContext: () => extractTraceContext,
+  getGraphQLOperationFromContext: () => getGraphQLOperationFromContext,
+  getGraphQLSpanFromContext: () => getGraphQLSpanFromContext,
+  getInstrumentationConfig: () => getInstrumentationConfig,
+  getLogger: () => getLogger,
+  getMetricsRegistry: () => getMetricsRegistry,
+  getTraceContext: () => getTraceContext,
+  getTracer: () => getTracer,
+  initializeInstrumentation: () => initializeInstrumentation,
+  initializeInstrumentationConfig: () => initializeInstrumentationConfig,
+  initializeMetricsRegistry: () => initializeMetricsRegistry,
+  initializeTracer: () => initializeTracer,
+  injectTraceContext: () => injectTraceContext,
+  instrumentResolver: () => instrumentResolver,
+  instrumentResolverMap: () => instrumentResolverMap,
+  instrumented: () => instrumented,
+  isApolloInlineTraceAvailable: () => isApolloInlineTraceAvailable,
+  isFeatureEnabled: () => isFeatureEnabled,
+  isInstrumentationConfigInitialized: () => isInstrumentationConfigInitialized,
+  isInstrumentationInitialized: () => isInstrumentationInitialized,
+  isMetricsRegistryInitialized: () => isMetricsRegistryInitialized,
+  isPrometheusAvailable: () => isPrometheusAvailable,
+  isTracerInitialized: () => isTracerInitialized,
+  logger: () => logger,
+  resetInstrumentation: () => resetInstrumentation,
+  resetInstrumentationConfig: () => resetInstrumentationConfig,
+  resetMetricsRegistry: () => resetMetricsRegistry,
+  setupInstrumentation: () => setupInstrumentation,
+  startSpan: () => startSpan,
+  traced: () => traced,
+  updateInstrumentationConfig: () => updateInstrumentationConfig,
+  withSpan: () => withSpan
+});
+
+// src/instrumentation/config.ts
+var ENV_VARS = {
+  // Master switch
+  INSTRUMENTATION_ENABLED: "INSTRUMENTATION_ENABLED",
+  // Feature flags
+  INSTRUMENTATION_TRACING: "INSTRUMENTATION_TRACING",
+  INSTRUMENTATION_METRICS: "INSTRUMENTATION_METRICS",
+  INSTRUMENTATION_LOGGING: "INSTRUMENTATION_LOGGING",
+  INSTRUMENTATION_GRAPHQL: "INSTRUMENTATION_GRAPHQL",
+  INSTRUMENTATION_DATABASE: "INSTRUMENTATION_DATABASE",
+  INSTRUMENTATION_HTTP: "INSTRUMENTATION_HTTP",
+  INSTRUMENTATION_CACHE: "INSTRUMENTATION_CACHE",
+  INSTRUMENTATION_EVENT_QUEUE: "INSTRUMENTATION_EVENT_QUEUE",
+  // Tracing
+  OTEL_SERVICE_NAME: "OTEL_SERVICE_NAME",
+  OTEL_SERVICE_VERSION: "OTEL_SERVICE_VERSION",
+  OTEL_ENVIRONMENT: "OTEL_ENVIRONMENT",
+  OTEL_EXPORTER_OTLP_ENDPOINT: "OTEL_EXPORTER_OTLP_ENDPOINT",
+  OTEL_EXPORTER_TYPE: "OTEL_EXPORTER_TYPE",
+  OTEL_SAMPLING_RATE: "OTEL_SAMPLING_RATE",
+  OTEL_PROPAGATION_FORMAT: "OTEL_PROPAGATION_FORMAT",
+  // Metrics
+  METRICS_EXPORTER_TYPE: "METRICS_EXPORTER_TYPE",
+  METRICS_PROMETHEUS_ENDPOINT: "METRICS_PROMETHEUS_ENDPOINT",
+  METRICS_PROMETHEUS_PORT: "METRICS_PROMETHEUS_PORT",
+  METRICS_COLLECT_INTERVAL: "METRICS_COLLECT_INTERVAL",
+  METRICS_DEFAULT_ENABLED: "METRICS_DEFAULT_ENABLED",
+  METRICS_PREFIX: "METRICS_PREFIX",
+  // Database
+  DB_INSTRUMENTATION_INCLUDE_STATEMENT: "DB_INSTRUMENTATION_INCLUDE_STATEMENT",
+  DB_INSTRUMENTATION_SLOW_QUERY_THRESHOLD: "DB_INSTRUMENTATION_SLOW_QUERY_THRESHOLD",
+  // GraphQL
+  GRAPHQL_INSTRUMENTATION_INCLUDE_DOCUMENT: "GRAPHQL_INSTRUMENTATION_INCLUDE_DOCUMENT",
+  GRAPHQL_INSTRUMENTATION_INCLUDE_VARIABLES: "GRAPHQL_INSTRUMENTATION_INCLUDE_VARIABLES",
+  GRAPHQL_INSTRUMENTATION_INCLUDE_RESOLVERS: "GRAPHQL_INSTRUMENTATION_INCLUDE_RESOLVERS"
+};
+function getEnvBoolean(key, defaultValue) {
+  const value = process.env[key];
+  if (value === void 0 || value === "") return defaultValue;
+  return value.toLowerCase() === "true" || value === "1";
+}
+__name(getEnvBoolean, "getEnvBoolean");
+function getEnvNumber(key, defaultValue) {
+  const value = process.env[key];
+  if (value === void 0 || value === "") return defaultValue;
+  const parsed = parseFloat(value);
+  return isNaN(parsed) ? defaultValue : parsed;
+}
+__name(getEnvNumber, "getEnvNumber");
+function getEnvString(key, defaultValue) {
+  const value = process.env[key];
+  return value !== void 0 && value !== "" ? value : defaultValue;
+}
+__name(getEnvString, "getEnvString");
+var DEFAULT_FEATURE_FLAGS = {
+  tracing: true,
+  metrics: true,
+  logging: true,
+  graphql: true,
+  database: true,
+  http: true,
+  cache: true,
+  eventQueue: true
+};
+var DEFAULT_TRACING_CONFIG = {
+  enabled: true,
+  serviceName: "unknown-service",
+  serviceVersion: "1.0.0",
+  environment: "development",
+  exporterType: "none",
+  samplingRate: 1,
+  propagationFormat: "w3c",
+  resourceAttributes: {},
+  ignoredRoutes: [
+    "/health",
+    "/ready",
+    "/live",
+    "/metrics"
+  ],
+  ignoredOperations: [
+    "IntrospectionQuery"
+  ]
+};
+var DEFAULT_METRICS_CONFIG = {
+  enabled: true,
+  serviceName: "unknown-service",
+  exporterType: "none",
+  prometheusEndpoint: "/metrics",
+  prometheusPort: 9090,
+  collectInterval: 6e4,
+  defaultMetrics: true,
+  metricPrefix: ""
+};
+var DEFAULT_LOGGING_CONFIG = {
+  enabled: true,
+  includeTraceId: true,
+  includeSpanId: true,
+  includeTraceFlags: false,
+  level: "info"
+};
+var DEFAULT_GRAPHQL_CONFIG = {
+  enabled: true,
+  includeDocument: false,
+  includeVariables: false,
+  includeResult: false,
+  documentDepth: 3,
+  ignoredOperations: [
+    "IntrospectionQuery"
+  ],
+  includeResolvers: true,
+  resolverSpanDepth: 3
+};
+var DEFAULT_DATABASE_CONFIG = {
+  enabled: true,
+  includeStatement: false,
+  includeParameters: false,
+  includeRowCount: true,
+  slowQueryThreshold: 1e3,
+  ignoredOperations: []
+};
+var DEFAULT_HTTP_CONFIG = {
+  enabled: true,
+  includeRequestHeaders: false,
+  includeResponseHeaders: false,
+  includeRequestBody: false,
+  includeResponseBody: false,
+  redactedHeaders: [
+    "authorization",
+    "cookie",
+    "set-cookie",
+    "x-api-key"
+  ],
+  ignoredRoutes: [
+    "/health",
+    "/ready",
+    "/live",
+    "/metrics"
+  ],
+  maxBodySize: 10240
+};
+var DEFAULT_CACHE_CONFIG = {
+  enabled: true,
+  includeKey: true,
+  includeValueSize: true,
+  includeTTL: true
+};
+var DEFAULT_EVENT_QUEUE_CONFIG = {
+  enabled: true,
+  includePayload: false,
+  includeHeaders: true,
+  maxPayloadSize: 1024
+};
+var globalConfig = null;
+function buildFeatureFlags(overrides) {
+  return {
+    tracing: getEnvBoolean(ENV_VARS.INSTRUMENTATION_TRACING, DEFAULT_FEATURE_FLAGS.tracing),
+    metrics: getEnvBoolean(ENV_VARS.INSTRUMENTATION_METRICS, DEFAULT_FEATURE_FLAGS.metrics),
+    logging: getEnvBoolean(ENV_VARS.INSTRUMENTATION_LOGGING, DEFAULT_FEATURE_FLAGS.logging),
+    graphql: getEnvBoolean(ENV_VARS.INSTRUMENTATION_GRAPHQL, DEFAULT_FEATURE_FLAGS.graphql),
+    database: getEnvBoolean(ENV_VARS.INSTRUMENTATION_DATABASE, DEFAULT_FEATURE_FLAGS.database),
+    http: getEnvBoolean(ENV_VARS.INSTRUMENTATION_HTTP, DEFAULT_FEATURE_FLAGS.http),
+    cache: getEnvBoolean(ENV_VARS.INSTRUMENTATION_CACHE, DEFAULT_FEATURE_FLAGS.cache),
+    eventQueue: getEnvBoolean(ENV_VARS.INSTRUMENTATION_EVENT_QUEUE, DEFAULT_FEATURE_FLAGS.eventQueue),
+    ...overrides
+  };
+}
+__name(buildFeatureFlags, "buildFeatureFlags");
+function buildTracingConfig(serviceName, overrides) {
+  return {
+    enabled: getEnvBoolean(ENV_VARS.INSTRUMENTATION_TRACING, DEFAULT_TRACING_CONFIG.enabled),
+    serviceName: getEnvString(ENV_VARS.OTEL_SERVICE_NAME, serviceName),
+    serviceVersion: getEnvString(ENV_VARS.OTEL_SERVICE_VERSION, DEFAULT_TRACING_CONFIG.serviceVersion),
+    environment: getEnvString(ENV_VARS.OTEL_ENVIRONMENT, process.env["NODE_ENV"] || "development"),
+    exporterEndpoint: process.env[ENV_VARS.OTEL_EXPORTER_OTLP_ENDPOINT],
+    exporterType: getEnvString(ENV_VARS.OTEL_EXPORTER_TYPE, DEFAULT_TRACING_CONFIG.exporterType),
+    samplingRate: getEnvNumber(ENV_VARS.OTEL_SAMPLING_RATE, DEFAULT_TRACING_CONFIG.samplingRate),
+    propagationFormat: getEnvString(ENV_VARS.OTEL_PROPAGATION_FORMAT, DEFAULT_TRACING_CONFIG.propagationFormat),
+    resourceAttributes: DEFAULT_TRACING_CONFIG.resourceAttributes,
+    ignoredRoutes: DEFAULT_TRACING_CONFIG.ignoredRoutes,
+    ignoredOperations: DEFAULT_TRACING_CONFIG.ignoredOperations,
+    ...overrides
+  };
+}
+__name(buildTracingConfig, "buildTracingConfig");
+function buildMetricsConfig(serviceName, overrides) {
+  return {
+    enabled: getEnvBoolean(ENV_VARS.INSTRUMENTATION_METRICS, DEFAULT_METRICS_CONFIG.enabled),
+    serviceName: getEnvString(ENV_VARS.OTEL_SERVICE_NAME, serviceName),
+    exporterEndpoint: process.env[ENV_VARS.OTEL_EXPORTER_OTLP_ENDPOINT],
+    exporterType: getEnvString(ENV_VARS.METRICS_EXPORTER_TYPE, DEFAULT_METRICS_CONFIG.exporterType),
+    prometheusEndpoint: getEnvString(ENV_VARS.METRICS_PROMETHEUS_ENDPOINT, DEFAULT_METRICS_CONFIG.prometheusEndpoint),
+    prometheusPort: getEnvNumber(ENV_VARS.METRICS_PROMETHEUS_PORT, DEFAULT_METRICS_CONFIG.prometheusPort),
+    collectInterval: getEnvNumber(ENV_VARS.METRICS_COLLECT_INTERVAL, DEFAULT_METRICS_CONFIG.collectInterval),
+    defaultMetrics: getEnvBoolean(ENV_VARS.METRICS_DEFAULT_ENABLED, DEFAULT_METRICS_CONFIG.defaultMetrics),
+    metricPrefix: getEnvString(ENV_VARS.METRICS_PREFIX, DEFAULT_METRICS_CONFIG.metricPrefix),
+    ...overrides
+  };
+}
+__name(buildMetricsConfig, "buildMetricsConfig");
+function buildDatabaseConfig(overrides) {
+  return {
+    enabled: getEnvBoolean(ENV_VARS.INSTRUMENTATION_DATABASE, DEFAULT_DATABASE_CONFIG.enabled),
+    includeStatement: getEnvBoolean(ENV_VARS.DB_INSTRUMENTATION_INCLUDE_STATEMENT, DEFAULT_DATABASE_CONFIG.includeStatement),
+    includeParameters: DEFAULT_DATABASE_CONFIG.includeParameters,
+    includeRowCount: DEFAULT_DATABASE_CONFIG.includeRowCount,
+    slowQueryThreshold: getEnvNumber(ENV_VARS.DB_INSTRUMENTATION_SLOW_QUERY_THRESHOLD, DEFAULT_DATABASE_CONFIG.slowQueryThreshold),
+    ignoredOperations: DEFAULT_DATABASE_CONFIG.ignoredOperations,
+    ...overrides
+  };
+}
+__name(buildDatabaseConfig, "buildDatabaseConfig");
+function buildGraphQLConfig(overrides) {
+  return {
+    enabled: getEnvBoolean(ENV_VARS.INSTRUMENTATION_GRAPHQL, DEFAULT_GRAPHQL_CONFIG.enabled),
+    includeDocument: getEnvBoolean(ENV_VARS.GRAPHQL_INSTRUMENTATION_INCLUDE_DOCUMENT, DEFAULT_GRAPHQL_CONFIG.includeDocument),
+    includeVariables: getEnvBoolean(ENV_VARS.GRAPHQL_INSTRUMENTATION_INCLUDE_VARIABLES, DEFAULT_GRAPHQL_CONFIG.includeVariables),
+    includeResult: DEFAULT_GRAPHQL_CONFIG.includeResult,
+    documentDepth: DEFAULT_GRAPHQL_CONFIG.documentDepth,
+    ignoredOperations: DEFAULT_GRAPHQL_CONFIG.ignoredOperations,
+    includeResolvers: getEnvBoolean(ENV_VARS.GRAPHQL_INSTRUMENTATION_INCLUDE_RESOLVERS, DEFAULT_GRAPHQL_CONFIG.includeResolvers),
+    resolverSpanDepth: DEFAULT_GRAPHQL_CONFIG.resolverSpanDepth,
+    ...overrides
+  };
+}
+__name(buildGraphQLConfig, "buildGraphQLConfig");
+function buildInstrumentationConfig(serviceName, overrides) {
+  const enabled = getEnvBoolean(ENV_VARS.INSTRUMENTATION_ENABLED, true);
+  return {
+    enabled,
+    features: buildFeatureFlags(overrides?.features),
+    tracing: buildTracingConfig(serviceName, overrides?.tracing),
+    metrics: buildMetricsConfig(serviceName, overrides?.metrics),
+    logging: {
+      ...DEFAULT_LOGGING_CONFIG,
+      ...overrides?.logging
+    },
+    graphql: buildGraphQLConfig(overrides?.graphql),
+    database: buildDatabaseConfig(overrides?.database),
+    http: {
+      ...DEFAULT_HTTP_CONFIG,
+      ...overrides?.http
+    },
+    cache: {
+      ...DEFAULT_CACHE_CONFIG,
+      ...overrides?.cache
+    },
+    eventQueue: {
+      ...DEFAULT_EVENT_QUEUE_CONFIG,
+      ...overrides?.eventQueue
+    }
+  };
+}
+__name(buildInstrumentationConfig, "buildInstrumentationConfig");
+function initializeInstrumentationConfig(serviceName, overrides) {
+  globalConfig = buildInstrumentationConfig(serviceName, overrides);
+  return globalConfig;
+}
+__name(initializeInstrumentationConfig, "initializeInstrumentationConfig");
+function getInstrumentationConfig() {
+  if (!globalConfig) {
+    throw new Error("Instrumentation config not initialized. Call initializeInstrumentationConfig() first.");
+  }
+  return globalConfig;
+}
+__name(getInstrumentationConfig, "getInstrumentationConfig");
+function isInstrumentationConfigInitialized() {
+  return globalConfig !== null;
+}
+__name(isInstrumentationConfigInitialized, "isInstrumentationConfigInitialized");
+function isFeatureEnabled(feature) {
+  if (!globalConfig) return false;
+  return globalConfig.enabled && globalConfig.features[feature];
+}
+__name(isFeatureEnabled, "isFeatureEnabled");
+function updateInstrumentationConfig(updates) {
+  if (!globalConfig) {
+    throw new Error("Instrumentation config not initialized. Call initializeInstrumentationConfig() first.");
+  }
+  globalConfig = {
+    ...globalConfig,
+    ...updates
+  };
+  return globalConfig;
+}
+__name(updateInstrumentationConfig, "updateInstrumentationConfig");
+function resetInstrumentationConfig() {
+  globalConfig = null;
+}
+__name(resetInstrumentationConfig, "resetInstrumentationConfig");
+
+// src/instrumentation/metrics-collector.ts
+function getLabelKey(labels) {
+  if (!labels || Object.keys(labels).length === 0) return "";
+  return Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${v}`).join(",");
+}
+__name(getLabelKey, "getLabelKey");
+var InMemoryCounter = class InMemoryCounter2 {
+  static {
+    __name(this, "InMemoryCounter");
+  }
+  values = /* @__PURE__ */ new Map();
+  name;
+  description;
+  constructor(name, description) {
+    this.name = name;
+    this.description = description;
+  }
+  add(value, labels) {
+    const key = getLabelKey(labels);
+    const current = this.values.get(key) || 0;
+    this.values.set(key, current + value);
+  }
+  inc(labels) {
+    this.add(1, labels);
+  }
+  getValue(labels) {
+    const key = getLabelKey(labels);
+    return this.values.get(key) || 0;
+  }
+  getName() {
+    return this.name;
+  }
+  getDescription() {
+    return this.description;
+  }
+  getAllValues() {
+    return new Map(this.values);
+  }
+  reset() {
+    this.values.clear();
+  }
+};
+var InMemoryHistogram = class InMemoryHistogram2 {
+  static {
+    __name(this, "InMemoryHistogram");
+  }
+  values = /* @__PURE__ */ new Map();
+  name;
+  description;
+  boundaries;
+  constructor(name, description, boundaries) {
+    this.name = name;
+    this.description = description;
+    this.boundaries = boundaries || [
+      5,
+      10,
+      25,
+      50,
+      100,
+      250,
+      500,
+      1e3,
+      2500,
+      5e3,
+      1e4
+    ];
+  }
+  record(value, labels) {
+    const key = getLabelKey(labels);
+    const existing = this.values.get(key) || [];
+    existing.push(value);
+    if (existing.length > 1e4) {
+      existing.shift();
+    }
+    this.values.set(key, existing);
+  }
+  getData(labels) {
+    const key = getLabelKey(labels);
+    const values = this.values.get(key) || [];
+    if (values.length === 0) {
+      return {
+        count: 0,
+        sum: 0,
+        min: 0,
+        max: 0,
+        avg: 0,
+        buckets: /* @__PURE__ */ new Map(),
+        percentiles: {
+          p50: 0,
+          p75: 0,
+          p90: 0,
+          p95: 0,
+          p99: 0
+        }
+      };
+    }
+    const sorted = [
+      ...values
+    ].sort((a, b) => a - b);
+    const sum = values.reduce((a, b) => a + b, 0);
+    const buckets = /* @__PURE__ */ new Map();
+    for (const boundary of this.boundaries) {
+      buckets.set(boundary, values.filter((v) => v <= boundary).length);
+    }
+    buckets.set(Infinity, values.length);
+    const percentile = /* @__PURE__ */ __name((p) => {
+      const index = Math.ceil(p / 100 * sorted.length) - 1;
+      return sorted[Math.max(0, index)] || 0;
+    }, "percentile");
+    return {
+      count: values.length,
+      sum,
+      min: sorted[0] || 0,
+      max: sorted[sorted.length - 1] || 0,
+      avg: sum / values.length,
+      buckets,
+      percentiles: {
+        p50: percentile(50),
+        p75: percentile(75),
+        p90: percentile(90),
+        p95: percentile(95),
+        p99: percentile(99)
+      }
+    };
+  }
+  getName() {
+    return this.name;
+  }
+  getDescription() {
+    return this.description;
+  }
+  getAllData() {
+    const result = /* @__PURE__ */ new Map();
+    for (const [key] of this.values) {
+      result.set(key, this.getData(key ? this.parseLabels(key) : void 0));
+    }
+    return result;
+  }
+  parseLabels(key) {
+    const labels = {};
+    for (const part of key.split(",")) {
+      const [k, v] = part.split("=");
+      if (k && v) labels[k] = v;
+    }
+    return labels;
+  }
+  reset() {
+    this.values.clear();
+  }
+};
+var InMemoryGauge = class InMemoryGauge2 {
+  static {
+    __name(this, "InMemoryGauge");
+  }
+  values = /* @__PURE__ */ new Map();
+  name;
+  description;
+  constructor(name, description) {
+    this.name = name;
+    this.description = description;
+  }
+  set(value, labels) {
+    const key = getLabelKey(labels);
+    this.values.set(key, value);
+  }
+  // eslint-disable-next-line sonarjs/no-identical-functions -- Shared implementation across metric types by design
+  add(value, labels) {
+    const key = getLabelKey(labels);
+    const current = this.values.get(key) || 0;
+    this.values.set(key, current + value);
+  }
+  sub(value, labels) {
+    this.add(-value, labels);
+  }
+  getValue(labels) {
+    const key = getLabelKey(labels);
+    return this.values.get(key) || 0;
+  }
+  getName() {
+    return this.name;
+  }
+  getDescription() {
+    return this.description;
+  }
+  getAllValues() {
+    return new Map(this.values);
+  }
+  reset() {
+    this.values.clear();
+  }
+};
+var InMemoryUpDownCounter = class InMemoryUpDownCounter2 {
+  static {
+    __name(this, "InMemoryUpDownCounter");
+  }
+  values = /* @__PURE__ */ new Map();
+  name;
+  description;
+  constructor(name, description) {
+    this.name = name;
+    this.description = description;
+  }
+  // eslint-disable-next-line sonarjs/no-identical-functions -- Shared implementation across metric types by design
+  add(value, labels) {
+    const key = getLabelKey(labels);
+    const current = this.values.get(key) || 0;
+    this.values.set(key, current + value);
+  }
+  getValue(labels) {
+    const key = getLabelKey(labels);
+    return this.values.get(key) || 0;
+  }
+  getName() {
+    return this.name;
+  }
+  getDescription() {
+    return this.description;
+  }
+  getAllValues() {
+    return new Map(this.values);
+  }
+  reset() {
+    this.values.clear();
+  }
+};
+var NoOpCounter = class NoOpCounter2 {
+  static {
+    __name(this, "NoOpCounter");
+  }
+  add() {
+  }
+  inc() {
+  }
+  getValue() {
+    return 0;
+  }
+};
+var NoOpHistogram = class NoOpHistogram2 {
+  static {
+    __name(this, "NoOpHistogram");
+  }
+  record() {
+  }
+  getData() {
+    return {
+      count: 0,
+      sum: 0,
+      min: 0,
+      max: 0,
+      avg: 0,
+      buckets: /* @__PURE__ */ new Map(),
+      percentiles: {
+        p50: 0,
+        p75: 0,
+        p90: 0,
+        p95: 0,
+        p99: 0
+      }
+    };
+  }
+};
+var NoOpGauge = class NoOpGauge2 {
+  static {
+    __name(this, "NoOpGauge");
+  }
+  set() {
+  }
+  add() {
+  }
+  sub() {
+  }
+  getValue() {
+    return 0;
+  }
+};
+var NoOpUpDownCounter = class NoOpUpDownCounter2 {
+  static {
+    __name(this, "NoOpUpDownCounter");
+  }
+  add() {
+  }
+  getValue() {
+    return 0;
+  }
+};
+var MetricsRegistry = class {
+  static {
+    __name(this, "MetricsRegistry");
+  }
+  counters = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  gauges = /* @__PURE__ */ new Map();
+  upDownCounters = /* @__PURE__ */ new Map();
+  serviceName;
+  metricPrefix;
+  constructor(serviceName, metricPrefix = "") {
+    this.serviceName = serviceName;
+    this.metricPrefix = metricPrefix;
+  }
+  /**
+  * Get service name
+  */
+  getServiceName() {
+    return this.serviceName;
+  }
+  /**
+  * Check if metrics are enabled
+  */
+  isEnabled() {
+    return isInstrumentationConfigInitialized() && isFeatureEnabled("metrics");
+  }
+  /**
+  * Get prefixed metric name
+  */
+  getPrefixedName(name) {
+    return this.metricPrefix ? `${this.metricPrefix}_${name}` : name;
+  }
+  /**
+  * Create or get a counter
+  */
+  createCounter(name, description) {
+    if (!this.isEnabled()) {
+      return new NoOpCounter();
+    }
+    const prefixedName = this.getPrefixedName(name);
+    let counter = this.counters.get(prefixedName);
+    if (!counter) {
+      counter = new InMemoryCounter(prefixedName, description);
+      this.counters.set(prefixedName, counter);
+    }
+    return counter;
+  }
+  /**
+  * Create or get a histogram
+  */
+  createHistogram(name, description, boundaries) {
+    if (!this.isEnabled()) {
+      return new NoOpHistogram();
+    }
+    const prefixedName = this.getPrefixedName(name);
+    let histogram = this.histograms.get(prefixedName);
+    if (!histogram) {
+      histogram = new InMemoryHistogram(prefixedName, description, boundaries);
+      this.histograms.set(prefixedName, histogram);
+    }
+    return histogram;
+  }
+  /**
+  * Create or get a gauge
+  */
+  createGauge(name, description) {
+    if (!this.isEnabled()) {
+      return new NoOpGauge();
+    }
+    const prefixedName = this.getPrefixedName(name);
+    let gauge = this.gauges.get(prefixedName);
+    if (!gauge) {
+      gauge = new InMemoryGauge(prefixedName, description);
+      this.gauges.set(prefixedName, gauge);
+    }
+    return gauge;
+  }
+  /**
+  * Create or get an up-down counter
+  */
+  createUpDownCounter(name, description) {
+    if (!this.isEnabled()) {
+      return new NoOpUpDownCounter();
+    }
+    const prefixedName = this.getPrefixedName(name);
+    let counter = this.upDownCounters.get(prefixedName);
+    if (!counter) {
+      counter = new InMemoryUpDownCounter(prefixedName, description);
+      this.upDownCounters.set(prefixedName, counter);
+    }
+    return counter;
+  }
+  /**
+  * Create metric from definition
+  */
+  createFromDefinition(definition) {
+    switch (definition.type) {
+      case "counter":
+        return this.createCounter(definition.name, definition.description);
+      case "histogram":
+        return this.createHistogram(definition.name, definition.description, definition.boundaries);
+      case "gauge":
+        return this.createGauge(definition.name, definition.description);
+      case "upDownCounter":
+        return this.createUpDownCounter(definition.name, definition.description);
+      default:
+        throw new Error(`Unknown metric type: ${definition.type}`);
+    }
+  }
+  /**
+  * Get all metrics data
+  */
+  getAllMetrics() {
+    return {
+      counters: Array.from(this.counters.values()).map((c) => ({
+        name: c.getName(),
+        description: c.getDescription(),
+        values: c.getAllValues()
+      })),
+      histograms: Array.from(this.histograms.values()).map((h) => ({
+        name: h.getName(),
+        description: h.getDescription(),
+        data: h.getAllData()
+      })),
+      gauges: Array.from(this.gauges.values()).map((g) => ({
+        name: g.getName(),
+        description: g.getDescription(),
+        values: g.getAllValues()
+      })),
+      upDownCounters: Array.from(this.upDownCounters.values()).map((c) => ({
+        name: c.getName(),
+        description: c.getDescription(),
+        values: c.getAllValues()
+      }))
+    };
+  }
+  /**
+  * Export counter metrics to Prometheus format
+  */
+  exportCountersToPrometheus(lines) {
+    for (const counter of this.counters.values()) {
+      lines.push(`# HELP ${counter.getName()} ${counter.getDescription()}`);
+      lines.push(`# TYPE ${counter.getName()} counter`);
+      for (const [labels, value] of counter.getAllValues()) {
+        const labelStr = labels ? `{${labels}}` : "";
+        lines.push(`${counter.getName()}${labelStr} ${value}`);
+      }
+    }
+  }
+  /**
+  * Export histogram metrics to Prometheus format
+  */
+  exportHistogramsToPrometheus(lines) {
+    for (const histogram of this.histograms.values()) {
+      lines.push(`# HELP ${histogram.getName()} ${histogram.getDescription()}`);
+      lines.push(`# TYPE ${histogram.getName()} histogram`);
+      for (const [labels, data] of histogram.getAllData()) {
+        const labelStr = labels ? `,${labels}` : "";
+        for (const [le, count] of data.buckets) {
+          const leStr = le === Infinity ? "+Inf" : le.toString();
+          lines.push(`${histogram.getName()}_bucket{le="${leStr}"${labelStr}} ${count}`);
+        }
+        lines.push(`${histogram.getName()}_sum{${labels || ""}} ${data.sum}`);
+        lines.push(`${histogram.getName()}_count{${labels || ""}} ${data.count}`);
+      }
+    }
+  }
+  /**
+  * Export gauge metrics to Prometheus format
+  */
+  exportGaugesToPrometheus(lines) {
+    for (const gauge of this.gauges.values()) {
+      lines.push(`# HELP ${gauge.getName()} ${gauge.getDescription()}`);
+      lines.push(`# TYPE ${gauge.getName()} gauge`);
+      for (const [labels, value] of gauge.getAllValues()) {
+        const labelStr = labels ? `{${labels}}` : "";
+        lines.push(`${gauge.getName()}${labelStr} ${value}`);
+      }
+    }
+  }
+  /**
+  * Export up-down counter metrics to Prometheus format (as gauges)
+  */
+  exportUpDownCountersToPrometheus(lines) {
+    for (const counter of this.upDownCounters.values()) {
+      lines.push(`# HELP ${counter.getName()} ${counter.getDescription()}`);
+      lines.push(`# TYPE ${counter.getName()} gauge`);
+      for (const [labels, value] of counter.getAllValues()) {
+        const labelStr = labels ? `{${labels}}` : "";
+        lines.push(`${counter.getName()}${labelStr} ${value}`);
+      }
+    }
+  }
+  /**
+  * Export metrics in Prometheus format
+  */
+  toPrometheusFormat() {
+    const lines = [];
+    this.exportCountersToPrometheus(lines);
+    this.exportHistogramsToPrometheus(lines);
+    this.exportGaugesToPrometheus(lines);
+    this.exportUpDownCountersToPrometheus(lines);
+    return lines.join("\n");
+  }
+  /**
+  * Reset all metrics
+  */
+  reset() {
+    for (const counter of this.counters.values()) {
+      counter.reset();
+    }
+    for (const histogram of this.histograms.values()) {
+      histogram.reset();
+    }
+    for (const gauge of this.gauges.values()) {
+      gauge.reset();
+    }
+    for (const counter of this.upDownCounters.values()) {
+      counter.reset();
+    }
+  }
+  /**
+  * Clear all metrics (remove registrations)
+  */
+  clear() {
+    this.counters.clear();
+    this.histograms.clear();
+    this.gauges.clear();
+    this.upDownCounters.clear();
+  }
+};
+var globalRegistry = null;
+function initializeMetricsRegistry(serviceName, metricPrefix = "") {
+  globalRegistry = new MetricsRegistry(serviceName, metricPrefix);
+  return globalRegistry;
+}
+__name(initializeMetricsRegistry, "initializeMetricsRegistry");
+function getMetricsRegistry() {
+  if (!globalRegistry) {
+    globalRegistry = new MetricsRegistry("unknown-service");
+  }
+  return globalRegistry;
+}
+__name(getMetricsRegistry, "getMetricsRegistry");
+function isMetricsRegistryInitialized() {
+  return globalRegistry !== null;
+}
+__name(isMetricsRegistryInitialized, "isMetricsRegistryInitialized");
+function resetMetricsRegistry() {
+  if (globalRegistry) {
+    globalRegistry.clear();
+  }
+  globalRegistry = null;
+}
+__name(resetMetricsRegistry, "resetMetricsRegistry");
+function createCounter(name, description) {
+  return getMetricsRegistry().createCounter(name, description);
+}
+__name(createCounter, "createCounter");
+function createHistogram(name, description, boundaries) {
+  return getMetricsRegistry().createHistogram(name, description, boundaries);
+}
+__name(createHistogram, "createHistogram");
+function createGauge(name, description) {
+  return getMetricsRegistry().createGauge(name, description);
+}
+__name(createGauge, "createGauge");
+function createUpDownCounter(name, description) {
+  return getMetricsRegistry().createUpDownCounter(name, description);
+}
+__name(createUpDownCounter, "createUpDownCounter");
+
+// src/instrumentation/tracer.ts
+var SpanStatus = /* @__PURE__ */ (function(SpanStatus2) {
+  SpanStatus2[SpanStatus2["UNSET"] = 0] = "UNSET";
+  SpanStatus2[SpanStatus2["OK"] = 1] = "OK";
+  SpanStatus2[SpanStatus2["ERROR"] = 2] = "ERROR";
+  return SpanStatus2;
+})({});
+var SpanKind = /* @__PURE__ */ (function(SpanKind2) {
+  SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL";
+  SpanKind2[SpanKind2["SERVER"] = 1] = "SERVER";
+  SpanKind2[SpanKind2["CLIENT"] = 2] = "CLIENT";
+  SpanKind2[SpanKind2["PRODUCER"] = 3] = "PRODUCER";
+  SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER";
+  return SpanKind2;
+})({});
+function generateTraceId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+__name(generateTraceId, "generateTraceId");
+function generateSpanId() {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+__name(generateSpanId, "generateSpanId");
+var InMemorySpan = class InMemorySpan2 {
+  static {
+    __name(this, "InMemorySpan");
+  }
+  name;
+  traceId;
+  spanId;
+  parentSpanId;
+  kind;
+  startTime;
+  endTime;
+  status = 0;
+  attributes = {};
+  events = [];
+  isRecording = true;
+  onEnd;
+  constructor(name, kind = 0, parentContext, onEnd) {
+    this.name = name;
+    this.kind = kind;
+    this.startTime = Date.now();
+    this.spanId = generateSpanId();
+    this.onEnd = onEnd;
+    if (parentContext) {
+      this.traceId = parentContext.traceId;
+      this.parentSpanId = parentContext.spanId;
+    } else {
+      this.traceId = generateTraceId();
+    }
+  }
+  setAttribute(key, value) {
+    if (this.isRecording) {
+      this.attributes[key] = value;
+    }
+    return this;
+  }
+  setAttributes(attributes) {
+    if (this.isRecording) {
+      Object.assign(this.attributes, attributes);
+    }
+    return this;
+  }
+  setStatus(status, message) {
+    this.status = status;
+    if (message) {
+      this.attributes["status.message"] = message;
+    }
+    return this;
+  }
+  recordException(error) {
+    this.status = 2;
+    this.attributes["error"] = true;
+    this.attributes["error.type"] = error.name;
+    this.attributes["error.message"] = error.message;
+    if (error.stack) {
+      this.attributes["error.stack"] = error.stack;
+    }
+    this.addEvent("exception", {
+      "exception.type": error.name,
+      "exception.message": error.message
+    });
+    return this;
+  }
+  addEvent(name, attributes) {
+    if (this.isRecording) {
+      this.events.push({
+        name,
+        timestamp: Date.now(),
+        attributes
+      });
+    }
+    return this;
+  }
+  end() {
+    if (!this.isRecording) return;
+    this.endTime = Date.now();
+    this.isRecording = false;
+    if (this.onEnd) {
+      this.onEnd(this);
+    }
+  }
+  getSpanContext() {
+    return {
+      traceId: this.traceId,
+      spanId: this.spanId,
+      traceFlags: this.status === 2 ? 1 : 0
+    };
+  }
+};
+var NoOpSpan = class NoOpSpan2 {
+  static {
+    __name(this, "NoOpSpan");
+  }
+  name = "";
+  traceId = "";
+  spanId = "";
+  kind = 0;
+  startTime = 0;
+  status = 0;
+  attributes = {};
+  events = [];
+  isRecording = false;
+  setAttribute() {
+    return this;
+  }
+  setAttributes() {
+    return this;
+  }
+  setStatus() {
+    return this;
+  }
+  recordException() {
+    return this;
+  }
+  addEvent() {
+    return this;
+  }
+  end() {
+  }
+  getSpanContext() {
+    return {
+      traceId: "",
+      spanId: "",
+      traceFlags: 0
+    };
+  }
+};
+var Tracer = class {
+  static {
+    __name(this, "Tracer");
+  }
+  serviceName;
+  activeSpans = /* @__PURE__ */ new Map();
+  currentSpan = null;
+  spanListeners = [];
+  constructor(serviceName) {
+    this.serviceName = serviceName;
+  }
+  /**
+  * Check if tracing is enabled
+  */
+  isEnabled() {
+    return isInstrumentationConfigInitialized() && isFeatureEnabled("tracing");
+  }
+  /**
+  * Start a new span
+  */
+  startSpan(name, kind = 0, parentContext) {
+    if (!this.isEnabled()) {
+      return new NoOpSpan();
+    }
+    const config = getInstrumentationConfig();
+    if (config.tracing.ignoredOperations?.includes(name)) {
+      return new NoOpSpan();
+    }
+    const parent = parentContext || this.currentSpan?.getSpanContext();
+    const span = new InMemorySpan(name, kind, parent, (completedSpan) => {
+      this.onSpanEnd(completedSpan);
+    });
+    span.setAttributes({
+      "service.name": this.serviceName,
+      "service.version": config.tracing.serviceVersion || "1.0.0",
+      "deployment.environment": config.tracing.environment || "development"
+    });
+    if (config.tracing.resourceAttributes) {
+      span.setAttributes(config.tracing.resourceAttributes);
+    }
+    this.activeSpans.set(span.spanId, span);
+    this.currentSpan = span;
+    return span;
+  }
+  /**
+  * Start a span from operation context
+  */
+  startSpanFromContext(context, kind = 0) {
+    const span = this.startSpan(context.operationName, kind);
+    if (span.isRecording) {
+      span.setAttributes({
+        "operation.type": context.operationType,
+        ...context.actorId && {
+          "actor.id": context.actorId
+        },
+        ...context.tenantId && {
+          "tenant.id": context.tenantId
+        },
+        ...context.workspaceId && {
+          "workspace.id": context.workspaceId
+        },
+        ...context.requestId && {
+          "request.id": context.requestId
+        },
+        ...context.attributes
+      });
+    }
+    return span;
+  }
+  /**
+  * Get current active span
+  */
+  getCurrentSpan() {
+    return this.currentSpan;
+  }
+  /**
+  * Get current trace context for logging
+  */
+  getTraceContext() {
+    if (!this.currentSpan || !this.isEnabled()) {
+      return {};
+    }
+    const spanContext = this.currentSpan.getSpanContext();
+    return {
+      traceId: spanContext.traceId,
+      spanId: spanContext.spanId,
+      traceFlags: spanContext.traceFlags,
+      parentSpanId: this.currentSpan.parentSpanId
+    };
+  }
+  /**
+  * Set current span (for context propagation)
+  */
+  setCurrentSpan(span) {
+    this.currentSpan = span;
+  }
+  /**
+  * Run a function within a span
+  */
+  async withSpan(name, fn, kind = 0, parentContext) {
+    const span = this.startSpan(name, kind, parentContext);
+    try {
+      const result = await fn(span);
+      span.setStatus(1);
+      return result;
+    } catch (error) {
+      if (error instanceof Error) {
+        span.recordException(error);
+      }
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+  /**
+  * Run a synchronous function within a span
+  */
+  withSpanSync(name, fn, kind = 0, parentContext) {
+    const span = this.startSpan(name, kind, parentContext);
+    try {
+      const result = fn(span);
+      span.setStatus(1);
+      return result;
+    } catch (error) {
+      if (error instanceof Error) {
+        span.recordException(error);
+      }
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+  /**
+  * Add a listener for completed spans
+  */
+  addSpanListener(listener) {
+    this.spanListeners.push(listener);
+  }
+  /**
+  * Remove a span listener
+  */
+  removeSpanListener(listener) {
+    const index = this.spanListeners.indexOf(listener);
+    if (index !== -1) {
+      this.spanListeners.splice(index, 1);
+    }
+  }
+  /**
+  * Handle span completion
+  */
+  onSpanEnd(span) {
+    this.activeSpans.delete(span.spanId);
+    if (this.currentSpan?.spanId === span.spanId) {
+      if (span.parentSpanId) {
+        this.currentSpan = this.activeSpans.get(span.parentSpanId) || null;
+      } else {
+        this.currentSpan = null;
+      }
+    }
+    const config = getInstrumentationConfig();
+    if (config.tracing.exporterType === "console") {
+      this.logSpan(span);
+    }
+    for (const listener of this.spanListeners) {
+      try {
+        listener(span);
+      } catch (error) {
+        logger.error("[Tracer] Error in span listener:", error);
+      }
+    }
+  }
+  /**
+  * Log span to console (for debugging)
+  */
+  logSpan(span) {
+    const duration = span.endTime ? span.endTime - span.startTime : 0;
+    logger.debug("[Tracer] Span completed", {
+      name: span.name,
+      traceId: span.traceId,
+      spanId: span.spanId,
+      parentSpanId: span.parentSpanId,
+      kind: SpanKind[span.kind],
+      status: SpanStatus[span.status],
+      duration: `${duration}ms`,
+      attributes: span.attributes,
+      eventCount: span.events.length
+    });
+  }
+  /**
+  * Get active span count
+  */
+  getActiveSpanCount() {
+    return this.activeSpans.size;
+  }
+  /**
+  * Clear all active spans (for testing)
+  */
+  clearActiveSpans() {
+    this.activeSpans.clear();
+    this.currentSpan = null;
+  }
+};
+var globalTracer = null;
+function initializeTracer(serviceName) {
+  globalTracer = new Tracer(serviceName);
+  return globalTracer;
+}
+__name(initializeTracer, "initializeTracer");
+function getTracer() {
+  if (!globalTracer) {
+    globalTracer = new Tracer("unknown-service");
+  }
+  return globalTracer;
+}
+__name(getTracer, "getTracer");
+function isTracerInitialized() {
+  return globalTracer !== null;
+}
+__name(isTracerInitialized, "isTracerInitialized");
+function startSpan(name, kind = 0, parentContext) {
+  return getTracer().startSpan(name, kind, parentContext);
+}
+__name(startSpan, "startSpan");
+async function withSpan(name, fn, kind = 0) {
+  return getTracer().withSpan(name, fn, kind);
+}
+__name(withSpan, "withSpan");
+function getTraceContext() {
+  return getTracer().getTraceContext();
+}
+__name(getTraceContext, "getTraceContext");
+function extractTraceContext(headers) {
+  const traceparent = headers["traceparent"];
+  if (!traceparent) return void 0;
+  const value = Array.isArray(traceparent) ? traceparent[0] : traceparent;
+  if (!value) return void 0;
+  const parts = value.split("-");
+  if (parts.length !== 4) return void 0;
+  const [, traceId, spanId, traceFlags] = parts;
+  if (!traceId || !spanId || traceId.length !== 32 || spanId.length !== 16) {
+    return void 0;
+  }
+  return {
+    traceId,
+    spanId,
+    traceFlags: parseInt(traceFlags || "0", 16),
+    isRemote: true
+  };
+}
+__name(extractTraceContext, "extractTraceContext");
+function injectTraceContext(headers, spanContext) {
+  const context = spanContext || getTracer().getCurrentSpan()?.getSpanContext();
+  if (!context || !context.traceId || !context.spanId) return;
+  headers["traceparent"] = `00-${context.traceId}-${context.spanId}-${context.traceFlags.toString(16).padStart(2, "0")}`;
+}
+__name(injectTraceContext, "injectTraceContext");
+
+// src/telemetry/logger-state.ts
+var activeTelemetryLogger;
+function setActiveTelemetryLogger(logger2) {
+  activeTelemetryLogger = logger2;
+}
+__name(setActiveTelemetryLogger, "setActiveTelemetryLogger");
+function getActiveTelemetryLogger() {
+  return activeTelemetryLogger;
+}
+__name(getActiveTelemetryLogger, "getActiveTelemetryLogger");
+
+// src/instrumentation/types.ts
+var STANDARD_METRICS = {
+  // HTTP metrics
+  HTTP_REQUEST_DURATION: {
+    name: "http_request_duration_ms",
+    description: "HTTP request duration in milliseconds",
+    type: "histogram",
+    unit: "ms",
+    labelKeys: [
+      "method",
+      "route",
+      "status_code"
+    ],
+    boundaries: [
+      5,
+      10,
+      25,
+      50,
+      100,
+      250,
+      500,
+      1e3,
+      2500,
+      5e3,
+      1e4
+    ]
+  },
+  HTTP_REQUEST_TOTAL: {
+    name: "http_requests_total",
+    description: "Total number of HTTP requests",
+    type: "counter",
+    labelKeys: [
+      "method",
+      "route",
+      "status_code"
+    ]
+  },
+  HTTP_REQUEST_SIZE: {
+    name: "http_request_size_bytes",
+    description: "HTTP request size in bytes",
+    type: "histogram",
+    unit: "bytes",
+    labelKeys: [
+      "method",
+      "route"
+    ],
+    boundaries: [
+      100,
+      1e3,
+      1e4,
+      1e5,
+      1e6
+    ]
+  },
+  HTTP_RESPONSE_SIZE: {
+    name: "http_response_size_bytes",
+    description: "HTTP response size in bytes",
+    type: "histogram",
+    unit: "bytes",
+    labelKeys: [
+      "method",
+      "route"
+    ],
+    boundaries: [
+      100,
+      1e3,
+      1e4,
+      1e5,
+      1e6
+    ]
+  },
+  // GraphQL metrics
+  GRAPHQL_OPERATION_DURATION: {
+    name: "graphql_operation_duration_ms",
+    description: "GraphQL operation duration in milliseconds",
+    type: "histogram",
+    unit: "ms",
+    labelKeys: [
+      "operation_type",
+      "operation_name"
+    ],
+    boundaries: [
+      5,
+      10,
+      25,
+      50,
+      100,
+      250,
+      500,
+      1e3,
+      2500,
+      5e3
+    ]
+  },
+  GRAPHQL_OPERATION_TOTAL: {
+    name: "graphql_operations_total",
+    description: "Total number of GraphQL operations",
+    type: "counter",
+    labelKeys: [
+      "operation_type",
+      "operation_name",
+      "status"
+    ]
+  },
+  GRAPHQL_RESOLVER_DURATION: {
+    name: "graphql_resolver_duration_ms",
+    description: "GraphQL resolver duration in milliseconds",
+    type: "histogram",
+    unit: "ms",
+    labelKeys: [
+      "type_name",
+      "field_name"
+    ],
+    boundaries: [
+      1,
+      5,
+      10,
+      25,
+      50,
+      100,
+      250,
+      500
+    ]
+  },
+  // Database metrics
+  DB_QUERY_DURATION: {
+    name: "db_query_duration_ms",
+    description: "Database query duration in milliseconds",
+    type: "histogram",
+    unit: "ms",
+    labelKeys: [
+      "operation",
+      "model"
+    ],
+    boundaries: [
+      1,
+      5,
+      10,
+      25,
+      50,
+      100,
+      250,
+      500,
+      1e3
+    ]
+  },
+  DB_QUERY_TOTAL: {
+    name: "db_queries_total",
+    description: "Total number of database queries",
+    type: "counter",
+    labelKeys: [
+      "operation",
+      "model",
+      "status"
+    ]
+  },
+  DB_CONNECTION_POOL_SIZE: {
+    name: "db_connection_pool_size",
+    description: "Database connection pool size",
+    type: "gauge",
+    labelKeys: [
+      "state"
+    ]
+  },
+  // Cache metrics
+  CACHE_OPERATION_DURATION: {
+    name: "cache_operation_duration_ms",
+    description: "Cache operation duration in milliseconds",
+    type: "histogram",
+    unit: "ms",
+    labelKeys: [
+      "operation"
+    ],
+    boundaries: [
+      0.1,
+      0.5,
+      1,
+      2,
+      5,
+      10,
+      25,
+      50
+    ]
+  },
+  CACHE_HIT_TOTAL: {
+    name: "cache_hits_total",
+    description: "Total number of cache hits",
+    type: "counter",
+    labelKeys: [
+      "cache_type"
+    ]
+  },
+  CACHE_MISS_TOTAL: {
+    name: "cache_misses_total",
+    description: "Total number of cache misses",
+    type: "counter",
+    labelKeys: [
+      "cache_type"
+    ]
+  },
+  // Business metrics
+  OPERATION_DURATION: {
+    name: "operation_duration_ms",
+    description: "Business operation duration in milliseconds",
+    type: "histogram",
+    unit: "ms",
+    labelKeys: [
+      "operation",
+      "status"
+    ],
+    boundaries: [
+      10,
+      50,
+      100,
+      250,
+      500,
+      1e3,
+      2500,
+      5e3,
+      1e4
+    ]
+  },
+  OPERATION_TOTAL: {
+    name: "operations_total",
+    description: "Total number of business operations",
+    type: "counter",
+    labelKeys: [
+      "operation",
+      "status"
+    ]
+  },
+  ACTIVE_OPERATIONS: {
+    name: "active_operations",
+    description: "Number of currently active operations",
+    type: "upDownCounter",
+    labelKeys: [
+      "operation"
+    ]
+  }
+};
+
+// src/instrumentation/graphql-plugin.ts
+var require2 = createRequire(import.meta.url);
+var prometheusPluginFactory = void 0;
+var prometheusLoadAttempted = false;
+function loadPrometheusPlugin() {
+  if (prometheusLoadAttempted) {
+    return prometheusPluginFactory ?? null;
+  }
+  prometheusLoadAttempted = true;
+  try {
+    const module = require2("@graphql-yoga/plugin-prometheus");
+    prometheusPluginFactory = module.usePrometheus;
+    if (prometheusPluginFactory) {
+      logger.info("[Instrumentation] Successfully loaded @graphql-yoga/plugin-prometheus");
+    } else {
+      logger.warn("[Instrumentation] @graphql-yoga/plugin-prometheus loaded but usePrometheus not found");
+    }
+    return prometheusPluginFactory ?? null;
+  } catch (error) {
+    logger.warn("[Instrumentation] Failed to load @graphql-yoga/plugin-prometheus:", error);
+    prometheusPluginFactory = null;
+    return null;
+  }
+}
+__name(loadPrometheusPlugin, "loadPrometheusPlugin");
+function createPrometheusPlugin(options) {
+  if (isInstrumentationConfigInitialized() && !isFeatureEnabled("metrics")) {
+    logger.debug("[Instrumentation] Metrics disabled, skipping Prometheus plugin");
+    return null;
+  }
+  const pluginFactory = loadPrometheusPlugin();
+  if (!pluginFactory) {
+    logger.debug("[Instrumentation] @graphql-yoga/plugin-prometheus not installed, metrics not available");
+    return null;
+  }
+  const config = {
+    // Expose metrics endpoint (set to false to disable, e.g., for push mode)
+    endpoint: options?.endpoint ?? "/metrics",
+    // Skip introspection queries from metrics
+    skipIntrospection: options?.skipIntrospection ?? true,
+    // Metrics configuration
+    metrics: {
+      // HTTP-level metrics
+      graphql_yoga_http_duration: options?.httpDuration ?? true,
+      // Operation-level metrics
+      graphql_envelop_request_duration: options?.requestDuration ?? true,
+      graphql_envelop_request_time_summary: options?.requestDuration ?? true,
+      graphql_envelop_request: options?.requestCount ?? true,
+      graphql_envelop_error_result: options?.errorCount ?? true,
+      graphql_envelop_deprecated_field: options?.deprecatedFields ?? true,
+      // Execution phase metrics
+      graphql_envelop_phase_parse: options?.parsePhase ?? true,
+      graphql_envelop_phase_validate: options?.validatePhase ?? true,
+      graphql_envelop_phase_context: options?.contextPhase ?? true,
+      graphql_envelop_phase_execute: options?.executePhase ?? true,
+      graphql_envelop_phase_subscribe: true,
+      // Schema change tracking
+      graphql_envelop_schema_change: true,
+      // Resolver-level metrics (disabled by default due to performance overhead)
+      graphql_envelop_execute_resolver: options?.resolverMetrics ?? false
+    },
+    // If resolver metrics enabled, optionally filter which resolvers to instrument
+    ...options?.instrumentResolvers && {
+      instrumentResolvers: options.instrumentResolvers
+    }
+  };
+  logger.debug("[Instrumentation] Using Prometheus metrics plugin", {
+    endpoint: config.endpoint,
+    resolverMetrics: options?.resolverMetrics ?? false
+  });
+  return pluginFactory(config);
+}
+__name(createPrometheusPlugin, "createPrometheusPlugin");
+function isPrometheusAvailable() {
+  return loadPrometheusPlugin() !== null;
+}
+__name(isPrometheusAvailable, "isPrometheusAvailable");
+var apolloInlineTracePluginFactory = void 0;
+var apolloInlineTraceLoadAttempted = false;
+function loadApolloInlineTracePlugin() {
+  if (apolloInlineTraceLoadAttempted) {
+    return apolloInlineTracePluginFactory ?? null;
+  }
+  apolloInlineTraceLoadAttempted = true;
+  try {
+    const module = require2("@graphql-yoga/plugin-apollo-inline-trace");
+    apolloInlineTracePluginFactory = module.useApolloInlineTrace;
+    return apolloInlineTracePluginFactory ?? null;
+  } catch {
+    apolloInlineTracePluginFactory = null;
+    return null;
+  }
+}
+__name(loadApolloInlineTracePlugin, "loadApolloInlineTracePlugin");
+function createApolloInlineTracePlugin(_options) {
+  if (isInstrumentationConfigInitialized() && !isFeatureEnabled("tracing")) {
+    logger.debug("[Instrumentation] Tracing disabled, skipping Apollo inline trace plugin");
+    return null;
+  }
+  const pluginFactory = loadApolloInlineTracePlugin();
+  if (!pluginFactory) {
+    logger.debug("[Instrumentation] @graphql-yoga/plugin-apollo-inline-trace not installed, using fallback tracing");
+    return null;
+  }
+  logger.debug("[Instrumentation] Using Apollo Federation inline trace plugin");
+  return pluginFactory();
+}
+__name(createApolloInlineTracePlugin, "createApolloInlineTracePlugin");
+function isApolloInlineTraceAvailable() {
+  return loadApolloInlineTracePlugin() !== null;
+}
+__name(isApolloInlineTraceAvailable, "isApolloInlineTraceAvailable");
+function createGraphQLMetrics() {
+  const def = STANDARD_METRICS;
+  return {
+    operationDuration: createHistogram(def["GRAPHQL_OPERATION_DURATION"]?.name || "graphql_operation_duration_ms", def["GRAPHQL_OPERATION_DURATION"]?.description || "GraphQL operation duration", def["GRAPHQL_OPERATION_DURATION"]?.boundaries),
+    operationTotal: createCounter(def["GRAPHQL_OPERATION_TOTAL"]?.name || "graphql_operations_total", def["GRAPHQL_OPERATION_TOTAL"]?.description || "Total GraphQL operations"),
+    operationErrors: createCounter("graphql_operation_errors_total", "Total GraphQL operation errors"),
+    resolverDuration: createHistogram(def["GRAPHQL_RESOLVER_DURATION"]?.name || "graphql_resolver_duration_ms", def["GRAPHQL_RESOLVER_DURATION"]?.description || "GraphQL resolver duration", def["GRAPHQL_RESOLVER_DURATION"]?.boundaries),
+    resolverTotal: createCounter("graphql_resolvers_total", "Total GraphQL resolver calls")
+  };
+}
+__name(createGraphQLMetrics, "createGraphQLMetrics");
+var graphqlMetrics = null;
+function getGraphQLMetrics() {
+  if (!graphqlMetrics) {
+    graphqlMetrics = createGraphQLMetrics();
+  }
+  return graphqlMetrics;
+}
+__name(getGraphQLMetrics, "getGraphQLMetrics");
+function extractOperationInfo(args) {
+  let operationType = "query";
+  let operationName = args.operationName || null;
+  const definitions = args.document?.definitions;
+  if (definitions && definitions.length > 0) {
+    for (const def of definitions) {
+      if (def.kind === "OperationDefinition") {
+        operationType = def.operation || "query";
+        if (!operationName && def.name?.value) {
+          operationName = def.name.value;
+        }
+        break;
+      }
+    }
+  }
+  return {
+    operationType,
+    operationName,
+    document: args.document?.loc?.source?.body,
+    variables: args.variableValues
+  };
+}
+__name(extractOperationInfo, "extractOperationInfo");
+function shouldIgnoreOperation(operationName) {
+  if (!isInstrumentationConfigInitialized()) return false;
+  const config = getInstrumentationConfig();
+  const ignoredOps = config.graphql.ignoredOperations || [];
+  return operationName ? ignoredOps.includes(operationName) : false;
+}
+__name(shouldIgnoreOperation, "shouldIgnoreOperation");
+function createGraphQLInstrumentationPlugin() {
+  return {
+    onExecute({ args }) {
+      if (!isFeatureEnabled("graphql")) {
+        return void 0;
+      }
+      const operationInfo = extractOperationInfo(args);
+      if (shouldIgnoreOperation(operationInfo.operationName)) {
+        return void 0;
+      }
+      const startTime = Date.now();
+      const config = getInstrumentationConfig();
+      const metrics = getGraphQLMetrics();
+      let span;
+      if (isFeatureEnabled("tracing")) {
+        const tracer = getTracer();
+        const spanName = operationInfo.operationName ? `GraphQL ${operationInfo.operationType} ${operationInfo.operationName}` : `GraphQL ${operationInfo.operationType}`;
+        span = tracer.startSpan(spanName, SpanKind.SERVER);
+        span.setAttributes({
+          "graphql.operation.type": operationInfo.operationType,
+          "graphql.operation.name": operationInfo.operationName || "anonymous"
+        });
+        if (config.graphql.includeDocument && operationInfo.document) {
+          span.setAttribute("graphql.document", operationInfo.document.substring(0, 2e3));
+        }
+        if (config.graphql.includeVariables && operationInfo.variables) {
+          try {
+            span.setAttribute("graphql.variables", JSON.stringify(operationInfo.variables).substring(0, 500));
+          } catch {
+          }
+        }
+      }
+      if (isFeatureEnabled("logging")) {
+        logger.debug("[GraphQL] Operation started", {
+          type: operationInfo.operationType,
+          name: operationInfo.operationName || "anonymous"
+        });
+      }
+      const context = args.contextValue;
+      if (context) {
+        context._instrumentation = {
+          span,
+          startTime,
+          operationInfo
+        };
+      }
+      return {
+        onExecuteDone({ result }) {
+          const duration = Date.now() - startTime;
+          const hasErrors = result && typeof result === "object" && "errors" in result && Array.isArray(result.errors) && result.errors.length > 0;
+          if (isFeatureEnabled("metrics")) {
+            const labels = {
+              operation_type: operationInfo.operationType,
+              operation_name: operationInfo.operationName || "anonymous"
+            };
+            metrics.operationDuration.record(duration, labels);
+            metrics.operationTotal.inc({
+              ...labels,
+              status: hasErrors ? "error" : "success"
+            });
+            if (hasErrors) {
+              metrics.operationErrors.inc(labels);
+            }
+          }
+          if (span) {
+            span.setAttribute("graphql.duration_ms", duration);
+            if (hasErrors) {
+              span.setStatus(SpanStatus.ERROR, "GraphQL operation had errors");
+              const errors = result.errors;
+              if (errors && errors.length > 0) {
+                span.setAttribute("graphql.error_count", errors.length);
+                span.addEvent("graphql.errors", {
+                  errors: errors.map((e) => e.message || "Unknown error").join("; ")
+                });
+              }
+            } else {
+              span.setStatus(SpanStatus.OK);
+            }
+            if (config.graphql.includeResult) {
+              try {
+                span.setAttribute("graphql.result", JSON.stringify(result).substring(0, 500));
+              } catch {
+              }
+            }
+            span.end();
+          }
+          if (isFeatureEnabled("logging")) {
+            if (hasErrors) {
+              logger.warn("[GraphQL] Operation completed with errors", {
+                type: operationInfo.operationType,
+                name: operationInfo.operationName || "anonymous",
+                duration: `${duration}ms`,
+                errorCount: (result.errors || []).length
+              });
+            } else {
+              logger.debug("[GraphQL] Operation completed", {
+                type: operationInfo.operationType,
+                name: operationInfo.operationName || "anonymous",
+                duration: `${duration}ms`
+              });
+            }
+          }
+        }
+      };
+    }
+  };
+}
+__name(createGraphQLInstrumentationPlugin, "createGraphQLInstrumentationPlugin");
+function instrumentResolver(name, resolver, options) {
+  const [typeName, fieldName] = name.includes(".") ? name.split(".", 2) : [
+    "Unknown",
+    name
+  ];
+  return async (...args) => {
+    if (!isFeatureEnabled("graphql")) {
+      return resolver(...args);
+    }
+    const config = getInstrumentationConfig();
+    const startTime = Date.now();
+    const metrics = getGraphQLMetrics();
+    let span;
+    if (isFeatureEnabled("tracing") && config.graphql.includeResolvers) {
+      const tracer = getTracer();
+      span = tracer.startSpan(`Resolver: ${name}`, SpanKind.INTERNAL);
+      span.setAttributes({
+        "graphql.resolver.type": typeName || "Unknown",
+        "graphql.resolver.field": fieldName || name,
+        ...options?.attributes
+      });
+      if (options?.includeArgs && args.length > 1) {
+        try {
+          span.setAttribute("graphql.resolver.args", JSON.stringify(args[1]).substring(0, 500));
+        } catch {
+        }
+      }
+    }
+    try {
+      const result = await resolver(...args);
+      if (span) {
+        span.setStatus(SpanStatus.OK);
+        if (options?.includeResult) {
+          try {
+            span.setAttribute("graphql.resolver.result", JSON.stringify(result).substring(0, 500));
+          } catch {
+          }
+        }
+      }
+      return result;
+    } catch (error) {
+      if (span && error instanceof Error) {
+        span.recordException(error);
+      }
+      throw error;
+    } finally {
+      const duration = Date.now() - startTime;
+      if (span) {
+        span.end();
+      }
+      if (isFeatureEnabled("metrics")) {
+        metrics.resolverDuration.record(duration, {
+          type_name: typeName || "Unknown",
+          field_name: fieldName || name
+        });
+        metrics.resolverTotal.inc({
+          type_name: typeName || "Unknown",
+          field_name: fieldName || name
+        });
+      }
+    }
+  };
+}
+__name(instrumentResolver, "instrumentResolver");
+function instrumentResolverMap(resolverMap, options) {
+  const result = {};
+  for (const [typeName, fields] of Object.entries(resolverMap)) {
+    if (options?.excludeTypes?.includes(typeName)) {
+      result[typeName] = fields;
+      continue;
+    }
+    if (options?.includeTypes && !options.includeTypes.includes(typeName)) {
+      result[typeName] = fields;
+      continue;
+    }
+    result[typeName] = {};
+    for (const [fieldName, resolver] of Object.entries(fields)) {
+      const fullName = `${typeName}.${fieldName}`;
+      if (options?.excludeFields?.includes(fullName)) {
+        result[typeName][fieldName] = resolver;
+        continue;
+      }
+      result[typeName][fieldName] = instrumentResolver(fullName, resolver);
+    }
+  }
+  return result;
+}
+__name(instrumentResolverMap, "instrumentResolverMap");
+function getGraphQLOperationFromContext(context) {
+  const instrumentedContext = context;
+  return instrumentedContext?._instrumentation?.operationInfo;
+}
+__name(getGraphQLOperationFromContext, "getGraphQLOperationFromContext");
+function getGraphQLSpanFromContext(context) {
+  const instrumentedContext = context;
+  return instrumentedContext?._instrumentation?.span;
+}
+__name(getGraphQLSpanFromContext, "getGraphQLSpanFromContext");
+
+// src/instrumentation/decorators.ts
+function Trace(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    if (typeof originalMethod !== "function") {
+      return descriptor;
+    }
+    const className = target.constructor.name;
+    const methodName = String(propertyKey);
+    const spanName = options.name || `${className}.${methodName}`;
+    descriptor.value = async function(...args) {
+      if (!isFeatureEnabled("tracing")) {
+        return originalMethod.apply(this, args);
+      }
+      if (options.skip) {
+        const shouldSkip = typeof options.skip === "function" ? options.skip(args) : options.skip;
+        if (shouldSkip) {
+          return originalMethod.apply(this, args);
+        }
+      }
+      const tracer = getTracer();
+      const span = tracer.startSpan(spanName, options.kind || SpanKind.INTERNAL);
+      span.setAttributes({
+        "code.function": methodName,
+        "code.namespace": className,
+        ...options.attributes
+      });
+      if (options.extractAttributes) {
+        try {
+          const extractedAttrs = options.extractAttributes(args);
+          span.setAttributes(extractedAttrs);
+        } catch {
+        }
+      }
+      if (options.includeArgs) {
+        try {
+          span.setAttribute("method.args", JSON.stringify(args).substring(0, 1e3));
+        } catch {
+        }
+      }
+      try {
+        const result = await originalMethod.apply(this, args);
+        if (options.includeResult) {
+          try {
+            span.setAttribute("method.result", JSON.stringify(result).substring(0, 1e3));
+          } catch {
+          }
+        }
+        span.setStatus(SpanStatus.OK);
+        return result;
+      } catch (error) {
+        if (error instanceof Error) {
+          span.recordException(error);
+        }
+        throw error;
+      } finally {
+        span.end();
+      }
+    };
+    return descriptor;
+  };
+}
+__name(Trace, "Trace");
+function Metric(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    if (typeof originalMethod !== "function") {
+      return descriptor;
+    }
+    const className = target.constructor.name;
+    const methodName = String(propertyKey);
+    const baseName = options.name || `${className.toLowerCase()}_${methodName.toLowerCase()}`;
+    const durationHistogram = createHistogram(`${baseName}_duration_ms`, `Duration of ${className}.${methodName} in milliseconds`, options.boundaries);
+    const totalCounter = createCounter(`${baseName}_total`, `Total calls to ${className}.${methodName}`);
+    const errorCounter = createCounter(`${baseName}_errors_total`, `Total errors in ${className}.${methodName}`);
+    descriptor.value = async function(...args) {
+      if (!isFeatureEnabled("metrics")) {
+        return originalMethod.apply(this, args);
+      }
+      const startTime = Date.now();
+      let result;
+      let hasError = false;
+      try {
+        result = await originalMethod.apply(this, args);
+        return result;
+      } catch (error) {
+        hasError = true;
+        throw error;
+      } finally {
+        const duration = Date.now() - startTime;
+        let labels = {};
+        if (options.labels) {
+          labels = typeof options.labels === "function" ? options.labels(args, result) : options.labels;
+        }
+        if (options.recordDuration !== false) {
+          durationHistogram.record(duration, labels);
+        }
+        if (options.recordCount !== false) {
+          totalCounter.inc({
+            ...labels,
+            status: hasError ? "error" : "success"
+          });
+        }
+        if (hasError) {
+          errorCounter.inc(labels);
+        }
+      }
+    };
+    return descriptor;
+  };
+}
+__name(Metric, "Metric");
+function Log(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    if (typeof originalMethod !== "function") {
+      return descriptor;
+    }
+    const className = target.constructor.name;
+    const methodName = String(propertyKey);
+    const level = options.level || "debug";
+    const logEntry = options.logEntry !== false;
+    const logExit = options.logExit !== false;
+    const logError = options.logError !== false;
+    descriptor.value = async function(...args) {
+      if (!isFeatureEnabled("logging")) {
+        return originalMethod.apply(this, args);
+      }
+      const baseMessage = options.message || `${className}.${methodName}`;
+      if (logEntry) {
+        const entryData = {
+          class: className,
+          method: methodName
+        };
+        if (options.includeArgs) {
+          entryData["args"] = args;
+        }
+        logger[level](`[Enter] ${baseMessage}`, entryData);
+      }
+      const startTime = Date.now();
+      try {
+        const result = await originalMethod.apply(this, args);
+        if (logExit) {
+          const duration = Date.now() - startTime;
+          const exitData = {
+            class: className,
+            method: methodName,
+            duration: `${duration}ms`
+          };
+          if (options.includeResult) {
+            exitData["result"] = result;
+          }
+          logger[level](`[Exit] ${baseMessage}`, exitData);
+        }
+        return result;
+      } catch (error) {
+        if (logError) {
+          const duration = Date.now() - startTime;
+          logger.error(`[Error] ${baseMessage}`, {
+            class: className,
+            method: methodName,
+            duration: `${duration}ms`,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+        throw error;
+      }
+    };
+    return descriptor;
+  };
+}
+__name(Log, "Log");
+function shouldSkipInstrumentation(skipOption, args) {
+  if (!skipOption) {
+    return false;
+  }
+  return typeof skipOption === "function" ? skipOption(args) : skipOption;
+}
+__name(shouldSkipInstrumentation, "shouldSkipInstrumentation");
+function startInstrumentationSpan(traceOpts, operationName, operationType, methodName, className, args) {
+  if (traceOpts === null || !isFeatureEnabled("tracing")) {
+    return null;
+  }
+  const tracer = getTracer();
+  const span = tracer.startSpan(traceOpts?.["name"] || operationName, traceOpts?.["kind"] || SpanKind.INTERNAL);
+  span.setAttributes({
+    "operation.type": operationType,
+    "code.function": methodName,
+    "code.namespace": className,
+    ...traceOpts?.["attributes"]
+  });
+  if (traceOpts?.["extractAttributes"]) {
+    try {
+      const extractFn = traceOpts["extractAttributes"];
+      span.setAttributes(extractFn(args));
+    } catch {
+    }
+  }
+  return span;
+}
+__name(startInstrumentationSpan, "startInstrumentationSpan");
+function logInstrumentationEntry(logOpts, operationName, operationType, args) {
+  if (logOpts === null || !isFeatureEnabled("logging")) {
+    return;
+  }
+  if (logOpts?.["logEntry"] === false) {
+    return;
+  }
+  const level = logOpts?.["level"] || "debug";
+  logger[level](`[Enter] ${operationName}`, {
+    operation: operationName,
+    type: operationType,
+    ...logOpts?.["includeArgs"] ? {
+      args
+    } : {}
+  });
+}
+__name(logInstrumentationEntry, "logInstrumentationEntry");
+function handleInstrumentationSuccess(span, traceOpts, result) {
+  if (!span) {
+    return;
+  }
+  span.setStatus(SpanStatus.OK);
+  if (traceOpts?.["includeResult"]) {
+    try {
+      span.setAttribute("result", JSON.stringify(result).substring(0, 500));
+    } catch {
+    }
+  }
+}
+__name(handleInstrumentationSuccess, "handleInstrumentationSuccess");
+function handleInstrumentationError(span, logOpts, operationName, operationType, error, startTime) {
+  if (span && error instanceof Error) {
+    span.recordException(error);
+  }
+  if (logOpts !== null && isFeatureEnabled("logging") && logOpts?.["logError"] !== false) {
+    logger.error(`[Error] ${operationName}`, {
+      operation: operationName,
+      type: operationType,
+      error: error instanceof Error ? error.message : String(error),
+      duration: `${Date.now() - startTime}ms`
+    });
+  }
+}
+__name(handleInstrumentationError, "handleInstrumentationError");
+function recordInstrumentationMetrics(metricOpts, durationHistogram, totalCounter, errorCounter, duration, args, result, hasError) {
+  if (metricOpts === null || !isFeatureEnabled("metrics")) {
+    return;
+  }
+  const labelsFn = metricOpts?.["labels"];
+  const labelsObj = metricOpts?.["labels"];
+  const labels = typeof metricOpts?.["labels"] === "function" ? labelsFn?.(args, result) : labelsObj || {};
+  if (durationHistogram && metricOpts?.["recordDuration"] !== false) {
+    durationHistogram.record(duration, labels);
+  }
+  if (totalCounter && metricOpts?.["recordCount"] !== false) {
+    totalCounter.inc({
+      ...labels,
+      status: hasError ? "error" : "success"
+    });
+  }
+  if (errorCounter && hasError) {
+    errorCounter.inc(labels);
+  }
+}
+__name(recordInstrumentationMetrics, "recordInstrumentationMetrics");
+function logInstrumentationExit(logOpts, operationName, operationType, duration, result, hasError) {
+  if (logOpts === null || !isFeatureEnabled("logging")) {
+    return;
+  }
+  if (logOpts?.["logExit"] === false || hasError) {
+    return;
+  }
+  const level = logOpts?.["level"] || "debug";
+  logger[level](`[Exit] ${operationName}`, {
+    operation: operationName,
+    type: operationType,
+    duration: `${duration}ms`,
+    ...logOpts?.["includeResult"] ? {
+      result
+    } : {}
+  });
+}
+__name(logInstrumentationExit, "logInstrumentationExit");
+function Instrument(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    if (typeof originalMethod !== "function") {
+      return descriptor;
+    }
+    const className = target.constructor.name;
+    const methodName = String(propertyKey);
+    const operationName = options.operationName || `${className}.${methodName}`;
+    const operationType = options.operationType || "internal";
+    let traceOpts;
+    if (options.trace === true) {
+      traceOpts = {};
+    } else if (options.trace === false || options.trace === void 0) {
+      traceOpts = null;
+    } else {
+      traceOpts = options.trace;
+    }
+    let metricOpts;
+    if (options.metrics === true) {
+      metricOpts = {};
+    } else if (options.metrics === false || options.metrics === void 0) {
+      metricOpts = null;
+    } else {
+      metricOpts = options.metrics;
+    }
+    let logOpts;
+    if (options.log === true) {
+      logOpts = {};
+    } else if (options.log === false || options.log === void 0) {
+      logOpts = null;
+    } else {
+      logOpts = options.log;
+    }
+    let durationHistogram = null;
+    let totalCounter = null;
+    let errorCounter = null;
+    if (metricOpts !== null) {
+      const baseName = metricOpts?.["name"] || `${className.toLowerCase()}_${methodName.toLowerCase()}`;
+      durationHistogram = createHistogram(`${baseName}_duration_ms`, `Duration of ${operationName} in ms`);
+      totalCounter = createCounter(`${baseName}_total`, `Total calls to ${operationName}`);
+      errorCounter = createCounter(`${baseName}_errors_total`, `Total errors in ${operationName}`);
+    }
+    descriptor.value = async function(...args) {
+      if (shouldSkipInstrumentation(options.skip, args)) {
+        return originalMethod.apply(this, args);
+      }
+      const startTime = Date.now();
+      let hasError = false;
+      let result;
+      const span = startInstrumentationSpan(traceOpts, operationName, operationType, methodName, className, args);
+      logInstrumentationEntry(logOpts, operationName, operationType, args);
+      try {
+        result = await originalMethod.apply(this, args);
+        handleInstrumentationSuccess(span, traceOpts, result);
+        return result;
+      } catch (error) {
+        hasError = true;
+        handleInstrumentationError(span, logOpts, operationName, operationType, error, startTime);
+        throw error;
+      } finally {
+        const duration = Date.now() - startTime;
+        if (span) {
+          span.end();
+        }
+        recordInstrumentationMetrics(metricOpts, durationHistogram, totalCounter, errorCounter, duration, args, result, hasError);
+        logInstrumentationExit(logOpts, operationName, operationType, duration, result, hasError);
+      }
+    };
+    return descriptor;
+  };
+}
+__name(Instrument, "Instrument");
+function traced(name, fn, options) {
+  return async (...args) => {
+    if (!isFeatureEnabled("tracing")) {
+      return fn(...args);
+    }
+    const tracer = getTracer();
+    const span = tracer.startSpan(name, options?.kind || SpanKind.INTERNAL);
+    if (options?.attributes) {
+      span.setAttributes(options.attributes);
+    }
+    try {
+      const result = await fn(...args);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (error) {
+      if (error instanceof Error) {
+        span.recordException(error);
+      }
+      throw error;
+    } finally {
+      span.end();
+    }
+  };
+}
+__name(traced, "traced");
+function instrumented(name, fn, options) {
+  const operationType = options?.operationType || "internal";
+  const durationHistogram = options?.metrics !== false ? createHistogram(`${name.toLowerCase()}_duration_ms`, `Duration of ${name} in ms`) : null;
+  const totalCounter = options?.metrics !== false ? createCounter(`${name.toLowerCase()}_total`, `Total calls to ${name}`) : null;
+  return async (...args) => {
+    const startTime = Date.now();
+    let span = null;
+    let hasError = false;
+    if (options?.trace !== false && isFeatureEnabled("tracing")) {
+      span = getTracer().startSpan(name, SpanKind.INTERNAL);
+      span.setAttribute("operation.type", operationType);
+    }
+    if (options?.log !== false && isFeatureEnabled("logging")) {
+      logger.debug(`[Enter] ${name}`, {
+        operation: name,
+        type: operationType
+      });
+    }
+    try {
+      const result = await fn(...args);
+      if (span) span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (error) {
+      hasError = true;
+      if (span && error instanceof Error) span.recordException(error);
+      throw error;
+    } finally {
+      const duration = Date.now() - startTime;
+      if (span) span.end();
+      if (durationHistogram && isFeatureEnabled("metrics")) {
+        durationHistogram.record(duration, {
+          status: hasError ? "error" : "success"
+        });
+      }
+      if (totalCounter && isFeatureEnabled("metrics")) {
+        totalCounter.inc({
+          status: hasError ? "error" : "success"
+        });
+      }
+      if (options?.log !== false && isFeatureEnabled("logging")) {
+        if (hasError) {
+          logger.error(`[Error] ${name}`, {
+            operation: name,
+            duration: `${duration}ms`
+          });
+        } else {
+          logger.debug(`[Exit] ${name}`, {
+            operation: name,
+            duration: `${duration}ms`
+          });
+        }
+      }
+    }
+  };
+}
+__name(instrumented, "instrumented");
+
+// src/instrumentation/index.ts
+function getLogger() {
+  return getActiveTelemetryLogger() ?? logger;
+}
+__name(getLogger, "getLogger");
+function initializeInstrumentation(serviceName, options) {
+  initializeInstrumentationConfig(serviceName, options);
+  initializeTracer(serviceName);
+  initializeMetricsRegistry(serviceName);
+  return {
+    tracer: getTracer(),
+    metrics: getMetricsRegistry(),
+    config: getInstrumentationConfig()
+  };
+}
+__name(initializeInstrumentation, "initializeInstrumentation");
+function isInstrumentationInitialized() {
+  return isInstrumentationConfigInitialized() && isTracerInitialized() && isMetricsRegistryInitialized();
+}
+__name(isInstrumentationInitialized, "isInstrumentationInitialized");
+function resetInstrumentation() {
+  resetInstrumentationConfig();
+  resetMetricsRegistry();
+}
+__name(resetInstrumentation, "resetInstrumentation");
+function setupInstrumentation(serviceName, options) {
+  const { tracer, metrics, config } = initializeInstrumentation(serviceName, options);
+  const plugins = [];
+  const useApollo = options?.useApolloInlineTrace ?? true;
+  if (useApollo) {
+    const apolloPlugin = createApolloInlineTracePlugin();
+    if (apolloPlugin) {
+      plugins.push(apolloPlugin);
+    }
+  }
+  const usePrometheus = options?.usePrometheus ?? true;
+  if (usePrometheus) {
+    const prometheusPlugin = createPrometheusPlugin(options?.prometheus);
+    if (prometheusPlugin) {
+      plugins.push(prometheusPlugin);
+    }
+  }
+  return {
+    tracer,
+    metrics,
+    config,
+    plugins
+  };
+}
+__name(setupInstrumentation, "setupInstrumentation");
+
+export { DEFAULT_CACHE_CONFIG, DEFAULT_DATABASE_CONFIG, DEFAULT_EVENT_QUEUE_CONFIG, DEFAULT_FEATURE_FLAGS, DEFAULT_GRAPHQL_CONFIG, DEFAULT_HTTP_CONFIG, DEFAULT_LOGGING_CONFIG, DEFAULT_METRICS_CONFIG, DEFAULT_TRACING_CONFIG, ENV_VARS, Instrument, Log, Metric, MetricsRegistry, STANDARD_METRICS, SpanKind, SpanStatus, Trace, Tracer, buildDatabaseConfig, buildFeatureFlags, buildGraphQLConfig, buildInstrumentationConfig, buildMetricsConfig, buildTracingConfig, createApolloInlineTracePlugin, createCounter, createGauge, createGraphQLInstrumentationPlugin, createHistogram, createPrometheusPlugin, createUpDownCounter, extractOperationInfo, extractTraceContext, getGraphQLOperationFromContext, getGraphQLSpanFromContext, getInstrumentationConfig, getLogger, getMetricsRegistry, getTraceContext, getTracer, initializeInstrumentation, initializeInstrumentationConfig, initializeMetricsRegistry, initializeTracer, injectTraceContext, instrumentResolver, instrumentResolverMap, instrumentation_exports, instrumented, isApolloInlineTraceAvailable, isFeatureEnabled, isInstrumentationConfigInitialized, isInstrumentationInitialized, isMetricsRegistryInitialized, isPrometheusAvailable, isTracerInitialized, resetInstrumentation, resetInstrumentationConfig, resetMetricsRegistry, setActiveTelemetryLogger, setupInstrumentation, startSpan, traced, updateInstrumentationConfig, withSpan };
+//# sourceMappingURL=chunk-4XAEES25.js.map
+//# sourceMappingURL=chunk-4XAEES25.js.map