@burdenoff/be-sdk 2026.518.2 → 2026.518.3

package/dist/chunk-REF7PANB.js

@@ -0,0 +1,852 @@
+import { __name } from './chunk-XE4OXN2W.js';
+
+// 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");
+
+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, MetricsRegistry, buildDatabaseConfig, buildFeatureFlags, buildGraphQLConfig, buildInstrumentationConfig, buildMetricsConfig, buildTracingConfig, createCounter, createGauge, createHistogram, createUpDownCounter, getInstrumentationConfig, getMetricsRegistry, initializeInstrumentationConfig, initializeMetricsRegistry, isFeatureEnabled, isInstrumentationConfigInitialized, isMetricsRegistryInitialized, resetInstrumentationConfig, resetMetricsRegistry, updateInstrumentationConfig };
+//# sourceMappingURL=chunk-REF7PANB.js.map
+//# sourceMappingURL=chunk-REF7PANB.js.map