@forklaunch/core 1.5.2 → 1.5.3

package/lib/http/index.js

@@ -61,6 +61,9 @@ __export(http_exports, {
   getCachedJwks: () => getCachedJwks,
   getCodeForStatus: () => getCodeForStatus,
   head: () => head,
+  httpErrorsTotalCounter: () => httpErrorsTotalCounter,
+  httpRequestDurationMsHistogram: () => httpRequestDurationMsHistogram,
+  httpRequestsInFlightCounter: () => httpRequestsInFlightCounter,
   httpRequestsTotalCounter: () => httpRequestsTotalCounter,
   httpServerDurationHistogram: () => httpServerDurationHistogram,
   isClientError: () => isClientError,
@@ -175,8 +178,9 @@ function isTypedHandler(maybeTypedHandler) {
 }
 
 // src/http/middleware/request/createContext.middleware.ts
-var import_common2 = require("@forklaunch/common");
-var import_api = require("@opentelemetry/api");
+var import_common4 = require("@forklaunch/common");
+var import_api3 = require("@opentelemetry/api");
+var import_semantic_conventions3 = require("@opentelemetry/semantic-conventions");
 var import_uuid = require("uuid");
 
 // src/http/telemetry/constants.ts
@@ -185,6 +189,327 @@ var ATTR_API_NAME = "api.name";
 var ATTR_CORRELATION_ID = "correlation.id";
 var ATTR_APPLICATION_ID = "application_id";
 
+// src/http/telemetry/openTelemetryCollector.ts
+var import_common3 = require("@forklaunch/common");
+var import_opentelemetry_instrumentation_hyper_express = require("@forklaunch/opentelemetry-instrumentation-hyper-express");
+var import_api2 = require("@opentelemetry/api");
+var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
+var import_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
+var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+var import_instrumentation_express = require("@opentelemetry/instrumentation-express");
+var import_instrumentation_http = require("@opentelemetry/instrumentation-http");
+var import_resources = require("@opentelemetry/resources");
+var import_sdk_logs = require("@opentelemetry/sdk-logs");
+var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
+var import_sdk_node = require("@opentelemetry/sdk-node");
+var import_semantic_conventions2 = require("@opentelemetry/semantic-conventions");
+var import_dotenv = __toESM(require("dotenv"));
+
+// src/http/guards/isForklaunchRequest.ts
+function isForklaunchRequest(request) {
+  return request != null && typeof request === "object" && "contractDetails" in request;
+}
+
+// src/http/telemetry/pinoLogger.ts
+var import_common2 = require("@forklaunch/common");
+var import_api = require("@opentelemetry/api");
+var import_api_logs = require("@opentelemetry/api-logs");
+var import_pino = __toESM(require("pino"));
+
+// src/http/guards/isLoggerMeta.ts
+function isLoggerMeta(arg) {
+  return typeof arg === "object" && arg !== null && "_meta" in arg;
+}
+
+// src/http/telemetry/pinoLogger.ts
+function meta(meta2) {
+  return meta2;
+}
+function mapSeverity(level) {
+  switch (level) {
+    case "silent":
+      return 0;
+    case "trace":
+      return 1;
+    case "debug":
+      return 5;
+    case "info":
+      return 9;
+    case "warn":
+      return 13;
+    case "error":
+      return 17;
+    case "fatal":
+      return 21;
+    default:
+      (0, import_common2.isNever)(level);
+      return 0;
+  }
+}
+function normalizeLogArgs(args) {
+  let message = "";
+  const metaObjects = [];
+  for (const arg of args) {
+    if (typeof arg === "string" && message === "") {
+      message = arg;
+    } else if (arg instanceof Error) {
+      metaObjects.push({
+        err: {
+          message: arg.message,
+          name: arg.name,
+          stack: arg.stack,
+          ...Object.keys(arg).length > 0 ? arg : {}
+        }
+      });
+    } else if (arg && typeof arg === "object" && !Array.isArray(arg)) {
+      metaObjects.push(arg);
+    } else {
+      message += ` ${String(arg)}`;
+    }
+  }
+  const metadata = Object.assign({}, ...metaObjects);
+  return [metadata, message.trim()];
+}
+function safePrettyFormat(level, args, timestamp) {
+  try {
+    const [metadata, message] = normalizeLogArgs(args);
+    const formattedTimestamp = timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    return `[${formattedTimestamp}] ${level.toUpperCase()}: ${message}${Object.keys(metadata).length > 0 ? `
+${JSON.stringify(metadata, null, 2)}` : ""}`;
+  } catch (error) {
+    const fallbackMessage = args.map((arg) => {
+      try {
+        if (typeof arg === "string") return arg;
+        if (arg === null) return "null";
+        if (arg === void 0) return "undefined";
+        return JSON.stringify(arg);
+      } catch {
+        return "[Circular/Non-serializable Object]";
+      }
+    }).join(" ");
+    return `[${(/* @__PURE__ */ new Date()).toISOString()}] ${level.toUpperCase()}: ${fallbackMessage} [Pretty Print Error: ${error instanceof Error ? error.message : "Unknown error"}]`;
+  }
+}
+var PinoLogger = class _PinoLogger {
+  _pinoLogger;
+  _meta;
+  constructor(level, meta2 = {}) {
+    this._pinoLogger = (0, import_pino.default)({
+      level: level || "info",
+      formatters: {
+        level(label) {
+          return { level: label };
+        }
+      },
+      timestamp: import_pino.default.stdTimeFunctions.isoTime,
+      transport: {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          errorLikeObjectKeys: ["err", "error"],
+          ignore: "pid,hostname",
+          translateTime: "SYS:standard"
+        }
+      }
+    });
+    this._meta = meta2;
+  }
+  log(level, ...args) {
+    let meta2 = {};
+    const filteredArgs = args.filter((arg) => {
+      if (isLoggerMeta(arg)) {
+        Object.assign(meta2, arg);
+        return false;
+      }
+      return true;
+    });
+    const [errorMetadata] = normalizeLogArgs(filteredArgs);
+    Object.assign(meta2, errorMetadata);
+    const activeSpan = import_api.trace.getActiveSpan();
+    if (activeSpan) {
+      const activeSpanContext = activeSpan.spanContext();
+      meta2.trace_id = activeSpanContext.traceId;
+      meta2.span_id = activeSpanContext.spanId;
+      meta2.trace_flags = activeSpanContext.traceFlags;
+      meta2 = {
+        // @ts-expect-error accessing private property
+        ...activeSpan.attributes,
+        ...meta2
+      };
+    }
+    meta2 = {
+      "api.name": "none",
+      "correlation.id": "none",
+      ...meta2
+    };
+    this._pinoLogger[level](...normalizeLogArgs(filteredArgs));
+    const formattedBody = safePrettyFormat(level, filteredArgs);
+    try {
+      import_api_logs.logs.getLogger(process.env.OTEL_SERVICE_NAME ?? "unknown").emit({
+        severityText: level,
+        severityNumber: mapSeverity(level),
+        body: formattedBody,
+        attributes: { ...this._meta, ...meta2 }
+      });
+    } catch (error) {
+      console.error("Failed to emit OpenTelemetry log:", error);
+      console.log(
+        `[${(/* @__PURE__ */ new Date()).toISOString()}] ${level.toUpperCase()}:`,
+        ...filteredArgs
+      );
+    }
+  }
+  error = (msg, ...args) => this.log("error", msg, ...args);
+  info = (msg, ...args) => this.log("info", msg, ...args);
+  debug = (msg, ...args) => this.log("debug", msg, ...args);
+  warn = (msg, ...args) => this.log("warn", msg, ...args);
+  trace = (msg, ...args) => this.log("trace", msg, ...args);
+  child(meta2 = {}) {
+    return new _PinoLogger(this._pinoLogger.level, { ...this._meta, ...meta2 });
+  }
+  getBaseLogger() {
+    return this._pinoLogger;
+  }
+};
+function logger(level, meta2 = {}) {
+  return new PinoLogger(level, meta2);
+}
+
+// src/http/telemetry/openTelemetryCollector.ts
+var OpenTelemetryCollector = class {
+  _logger;
+  _serviceName;
+  _metrics;
+  // scoped creation and create this in middleware when api execute. Also add correlation id
+  constructor(serviceName, level, metricDefinitions) {
+    this._serviceName = serviceName;
+    this._logger = logger(level || "info");
+    this._metrics = {};
+    for (const [metricId, metricType] of Object.entries(
+      metricDefinitions ?? {}
+    )) {
+      switch (metricType) {
+        case "counter":
+          this._metrics[metricId] = import_api2.metrics.getMeter(this._serviceName).createCounter(metricId);
+          break;
+        case "gauge":
+          this._metrics[metricId] = import_api2.metrics.getMeter(this._serviceName).createGauge(metricId);
+          break;
+        case "histogram":
+          this._metrics[metricId] = import_api2.metrics.getMeter(this._serviceName).createHistogram(metricId);
+          break;
+        case "upDownCounter":
+          this._metrics[metricId] = import_api2.metrics.getMeter(this._serviceName).createUpDownCounter(metricId);
+          break;
+        case "observableCounter":
+          this._metrics[metricId] = import_api2.metrics.getMeter(this._serviceName).createObservableCounter(metricId);
+          break;
+        case "observableGauge":
+          this._metrics[metricId] = import_api2.metrics.getMeter(this._serviceName).createObservableGauge(metricId);
+          break;
+        case "observableUpDownCounter":
+          this._metrics[metricId] = import_api2.metrics.getMeter(this._serviceName).createObservableUpDownCounter(metricId);
+          break;
+      }
+    }
+    this.log(
+      "info",
+      "OpenTelemetry Collector (Traces + Logs + Metrics) started"
+    );
+  }
+  log(level, ...args) {
+    this._logger.log(level, ...args);
+  }
+  info = (msg, ...args) => {
+    this._logger.log("info", msg, ...args);
+  };
+  error = (msg, ...args) => {
+    this._logger.log("error", msg, ...args);
+  };
+  warn = (msg, ...args) => {
+    this._logger.log("warn", msg, ...args);
+  };
+  debug = (msg, ...args) => {
+    this._logger.log("debug", msg, ...args);
+  };
+  trace = (msg, ...args) => {
+    this._logger.log("trace", msg, ...args);
+  };
+  getMetric(metricId) {
+    return this._metrics[metricId];
+  }
+};
+import_dotenv.default.config({ path: (0, import_common3.getEnvVar)("DOTENV_FILE_PATH") });
+function parseOtelHeaders() {
+  const headersEnv = (0, import_common3.getEnvVar)("OTEL_EXPORTER_OTLP_HEADERS");
+  if (!headersEnv) return void 0;
+  const headers = {};
+  for (const pair of headersEnv.split(",")) {
+    const [key, ...valueParts] = pair.split("=");
+    if (key && valueParts.length > 0) {
+      headers[key.trim()] = valueParts.join("=").trim();
+    }
+  }
+  return Object.keys(headers).length > 0 ? headers : void 0;
+}
+var otelHeaders = parseOtelHeaders();
+new import_sdk_node.NodeSDK({
+  resource: (0, import_resources.resourceFromAttributes)({
+    [import_semantic_conventions2.ATTR_SERVICE_NAME]: (0, import_common3.getEnvVar)("OTEL_SERVICE_NAME")
+  }),
+  traceExporter: new import_exporter_trace_otlp_http.OTLPTraceExporter({
+    url: `${(0, import_common3.getEnvVar)("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/traces`,
+    headers: otelHeaders
+  }),
+  metricReader: new import_sdk_metrics.PeriodicExportingMetricReader({
+    exporter: new import_exporter_metrics_otlp_http.OTLPMetricExporter({
+      url: `${(0, import_common3.getEnvVar)("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/metrics`,
+      headers: otelHeaders
+    }),
+    exportIntervalMillis: 5e3
+  }),
+  logRecordProcessors: [
+    new import_sdk_logs.BatchLogRecordProcessor({
+      exporter: new import_exporter_logs_otlp_http.OTLPLogExporter({
+        url: `${(0, import_common3.getEnvVar)("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/logs`,
+        headers: otelHeaders
+      })
+    })
+  ],
+  instrumentations: [
+    new import_instrumentation_http.HttpInstrumentation({
+      applyCustomAttributesOnSpan: (span, request) => {
+        span.setAttribute(
+          import_semantic_conventions2.ATTR_SERVICE_NAME,
+          (0, import_common3.getEnvVar)("OTEL_SERVICE_NAME") ?? "unknown"
+        );
+        if (isForklaunchRequest(request)) {
+          span.setAttribute(ATTR_API_NAME, request.contractDetails?.name);
+          span.setAttribute(ATTR_CORRELATION_ID, request.context.correlationId);
+        }
+      }
+    }),
+    new import_instrumentation_express.ExpressInstrumentation(),
+    new import_opentelemetry_instrumentation_hyper_express.HyperExpressInstrumentation()
+  ]
+}).start();
+var httpRequestsTotalCounter = import_api2.metrics.getMeter((0, import_common3.getEnvVar)("OTEL_SERVICE_NAME") || "unknown").createCounter("http_requests_total", {
+  description: "Number of HTTP requests"
+});
+var httpServerDurationHistogram = import_api2.metrics.getMeter((0, import_common3.getEnvVar)("OTEL_SERVICE_NAME") || "unknown").createHistogram("http_server_duration", {
+  description: "Duration of HTTP server requests",
+  unit: "s"
+});
+var httpRequestDurationMsHistogram = import_api2.metrics.getMeter((0, import_common3.getEnvVar)("OTEL_SERVICE_NAME") || "unknown").createHistogram("http_request_duration_ms", {
+  description: "Duration of HTTP requests in milliseconds"
+});
+var httpErrorsTotalCounter = import_api2.metrics.getMeter((0, import_common3.getEnvVar)("OTEL_SERVICE_NAME") || "unknown").createCounter("http_errors_total", {
+  description: "Total number of HTTP errors (4xx/5xx)"
+});
+var httpRequestsInFlightCounter = import_api2.metrics.getMeter((0, import_common3.getEnvVar)("OTEL_SERVICE_NAME") || "unknown").createUpDownCounter("http_requests_in_flight", {
+  description: "Number of HTTP requests currently in flight"
+});
+
 // src/http/middleware/request/createContext.middleware.ts
 function createContext(schemaValidator) {
   return function setContext(req, res, next) {
@@ -195,16 +520,30 @@ function createContext(schemaValidator) {
     }
     res.setHeader("x-correlation-id", correlationId);
     req.context = {
-      correlationId
+      correlationId,
+      requestStartTime: Date.now()
     };
-    const span = import_api.trace.getSpan(import_api.context.active());
+    const serviceName = (0, import_common4.getEnvVar)("OTEL_SERVICE_NAME") || "unknown";
+    const inFlightAttrs = {
+      [import_semantic_conventions3.ATTR_SERVICE_NAME]: serviceName
+    };
+    let inFlightActive = true;
+    const decrementInFlight = () => {
+      if (!inFlightActive) {
+        return;
+      }
+      httpRequestsInFlightCounter.add(-1, inFlightAttrs);
+      inFlightActive = false;
+    };
+    httpRequestsInFlightCounter.add(1, inFlightAttrs);
+    res.on("finish", decrementInFlight);
+    res.on("close", decrementInFlight);
+    res.on("error", decrementInFlight);
+    const span = import_api3.trace.getSpan(import_api3.context.active());
     if (span != null) {
       req.context.span = span;
       req.context.span?.setAttribute(ATTR_CORRELATION_ID, correlationId);
-      req.context.span?.setAttribute(
-        import_semantic_conventions.ATTR_SERVICE_NAME,
-        (0, import_common2.getEnvVar)("OTEL_SERVICE_NAME")
-      );
+      req.context.span?.setAttribute(import_semantic_conventions.ATTR_SERVICE_NAME, serviceName);
     }
     next?.();
   };
@@ -370,15 +709,15 @@ function isHttpContractDetails(maybeContractDetails) {
 }
 
 // src/http/middleware/request/auth.middleware.ts
-var import_common6 = require("@forklaunch/common");
+var import_common7 = require("@forklaunch/common");
 var import_validator = require("@forklaunch/validator");
 
 // src/http/discriminateAuthMethod.ts
-var import_common4 = require("@forklaunch/common");
+var import_common6 = require("@forklaunch/common");
 var import_jose = require("jose");
 
 // src/http/createHmacToken.ts
-var import_common3 = require("@forklaunch/common");
+var import_common5 = require("@forklaunch/common");
 var import_crypto = require("crypto");
 function createHmacToken({
   method,
@@ -389,7 +728,7 @@ function createHmacToken({
   secretKey
 }) {
   const hmac = (0, import_crypto.createHmac)("sha256", secretKey);
-  const bodyString = body ? `${(0, import_common3.safeStringify)(body)}
+  const bodyString = body ? `${(0, import_common5.safeStringify)(body)}
 ` : void 0;
   hmac.update(
     `${method}
@@ -464,253 +803,88 @@ async function discriminateAuthMethod(auth, openTelemetryCollector) {
     } else {
       let jwks;
       if ("jwksPublicKeyUrl" in jwt) {
-        jwks = await getCachedJwks(jwt.jwksPublicKeyUrl);
-      } else if ("jwksPublicKey" in jwt) {
-        jwks = [jwt.jwksPublicKey];
-      }
-      verificationFunction = async (token) => {
-        for (const key of jwks) {
-          try {
-            const { payload } = await (0, import_jose.jwtVerify)(token, key);
-            return payload;
-          } catch {
-            cachedJwks.value = null;
-            cachedJwks.lastUpdated = null;
-            cachedJwks.ttl = DEFAULT_TTL;
-            continue;
-          }
-        }
-      };
-    }
-    authMethod = {
-      type: "jwt",
-      auth: {
-        decodeResource: auth.decodeResource,
-        verificationFunction
-      }
-    };
-  } else if (isHmacMethod(auth)) {
-    authMethod = {
-      type: "hmac",
-      auth: {
-        secretKeys: auth.hmac.secretKeys,
-        verificationFunction: async ({
-          method,
-          path,
-          body,
-          timestamp,
-          nonce,
-          signature,
-          secretKey
-        }) => {
-          const computedSignature = createHmacToken({
-            method,
-            path,
-            body,
-            timestamp,
-            nonce,
-            secretKey
-          });
-          const isValid = computedSignature === signature;
-          if (!isValid) {
-            const errorInfo = {
-              method,
-              path,
-              timestamp: timestamp.toISOString(),
-              nonce,
-              receivedSignature: signature,
-              computedSignature
-            };
-            openTelemetryCollector?.debug("[HMAC Verification Failed]", {
-              ...errorInfo,
-              bodyType: body ? typeof body : "undefined",
-              body: body ? (0, import_common4.safeStringify)(body) : "undefined"
-            });
-          }
-          return isValid;
-        }
-      }
-    };
-  }
-  if (authMethod == null) {
-    throw new Error("Invalid auth method");
-  }
-  return authMethod;
-}
-
-// src/http/guards/hasFeatureChecks.ts
-function hasFeatureChecks(maybeFeatureAuth) {
-  return typeof maybeFeatureAuth === "object" && maybeFeatureAuth !== null && "requiredFeatures" in maybeFeatureAuth && Array.isArray(maybeFeatureAuth.requiredFeatures) && maybeFeatureAuth.requiredFeatures.length > 0;
-}
-
-// src/http/guards/hasSubscriptionChecks.ts
-function hasSubscriptionChecks(maybeSubscriptionAuth) {
-  return typeof maybeSubscriptionAuth === "object" && maybeSubscriptionAuth !== null && "requireActiveSubscription" in maybeSubscriptionAuth && maybeSubscriptionAuth.requireActiveSubscription === true;
-}
-
-// src/http/telemetry/pinoLogger.ts
-var import_common5 = require("@forklaunch/common");
-var import_api2 = require("@opentelemetry/api");
-var import_api_logs = require("@opentelemetry/api-logs");
-var import_pino = __toESM(require("pino"));
-
-// src/http/guards/isLoggerMeta.ts
-function isLoggerMeta(arg) {
-  return typeof arg === "object" && arg !== null && "_meta" in arg;
-}
-
-// src/http/telemetry/pinoLogger.ts
-function meta(meta2) {
-  return meta2;
-}
-function mapSeverity(level) {
-  switch (level) {
-    case "silent":
-      return 0;
-    case "trace":
-      return 1;
-    case "debug":
-      return 5;
-    case "info":
-      return 9;
-    case "warn":
-      return 13;
-    case "error":
-      return 17;
-    case "fatal":
-      return 21;
-    default:
-      (0, import_common5.isNever)(level);
-      return 0;
-  }
-}
-function normalizeLogArgs(args) {
-  let message = "";
-  const metaObjects = [];
-  for (const arg of args) {
-    if (typeof arg === "string" && message === "") {
-      message = arg;
-    } else if (arg instanceof Error) {
-      metaObjects.push({
-        err: {
-          message: arg.message,
-          name: arg.name,
-          stack: arg.stack,
-          ...Object.keys(arg).length > 0 ? arg : {}
-        }
-      });
-    } else if (arg && typeof arg === "object" && !Array.isArray(arg)) {
-      metaObjects.push(arg);
-    } else {
-      message += ` ${String(arg)}`;
-    }
-  }
-  const metadata = Object.assign({}, ...metaObjects);
-  return [metadata, message.trim()];
-}
-function safePrettyFormat(level, args, timestamp) {
-  try {
-    const [metadata, message] = normalizeLogArgs(args);
-    const formattedTimestamp = timestamp || (/* @__PURE__ */ new Date()).toISOString();
-    return `[${formattedTimestamp}] ${level.toUpperCase()}: ${message}${Object.keys(metadata).length > 0 ? `
-${JSON.stringify(metadata, null, 2)}` : ""}`;
-  } catch (error) {
-    const fallbackMessage = args.map((arg) => {
-      try {
-        if (typeof arg === "string") return arg;
-        if (arg === null) return "null";
-        if (arg === void 0) return "undefined";
-        return JSON.stringify(arg);
-      } catch {
-        return "[Circular/Non-serializable Object]";
-      }
-    }).join(" ");
-    return `[${(/* @__PURE__ */ new Date()).toISOString()}] ${level.toUpperCase()}: ${fallbackMessage} [Pretty Print Error: ${error instanceof Error ? error.message : "Unknown error"}]`;
-  }
-}
-var PinoLogger = class _PinoLogger {
-  _pinoLogger;
-  _meta;
-  constructor(level, meta2 = {}) {
-    this._pinoLogger = (0, import_pino.default)({
-      level: level || "info",
-      formatters: {
-        level(label) {
-          return { level: label };
-        }
-      },
-      timestamp: import_pino.default.stdTimeFunctions.isoTime,
-      transport: {
-        target: "pino-pretty",
-        options: {
-          colorize: true,
-          errorLikeObjectKeys: ["err", "error"],
-          ignore: "pid,hostname",
-          translateTime: "SYS:standard"
-        }
-      }
-    });
-    this._meta = meta2;
-  }
-  log(level, ...args) {
-    let meta2 = {};
-    const filteredArgs = args.filter((arg) => {
-      if (isLoggerMeta(arg)) {
-        Object.assign(meta2, arg);
-        return false;
+        jwks = await getCachedJwks(jwt.jwksPublicKeyUrl);
+      } else if ("jwksPublicKey" in jwt) {
+        jwks = [jwt.jwksPublicKey];
       }
-      return true;
-    });
-    const [errorMetadata] = normalizeLogArgs(filteredArgs);
-    Object.assign(meta2, errorMetadata);
-    const activeSpan = import_api2.trace.getActiveSpan();
-    if (activeSpan) {
-      const activeSpanContext = activeSpan.spanContext();
-      meta2.trace_id = activeSpanContext.traceId;
-      meta2.span_id = activeSpanContext.spanId;
-      meta2.trace_flags = activeSpanContext.traceFlags;
-      meta2 = {
-        // @ts-expect-error accessing private property
-        ...activeSpan.attributes,
-        ...meta2
+      verificationFunction = async (token) => {
+        for (const key of jwks) {
+          try {
+            const { payload } = await (0, import_jose.jwtVerify)(token, key);
+            return payload;
+          } catch {
+            cachedJwks.value = null;
+            cachedJwks.lastUpdated = null;
+            cachedJwks.ttl = DEFAULT_TTL;
+            continue;
+          }
+        }
       };
     }
-    meta2 = {
-      "api.name": "none",
-      "correlation.id": "none",
-      ...meta2
+    authMethod = {
+      type: "jwt",
+      auth: {
+        decodeResource: auth.decodeResource,
+        verificationFunction
+      }
+    };
+  } else if (isHmacMethod(auth)) {
+    authMethod = {
+      type: "hmac",
+      auth: {
+        secretKeys: auth.hmac.secretKeys,
+        verificationFunction: async ({
+          method,
+          path,
+          body,
+          timestamp,
+          nonce,
+          signature,
+          secretKey
+        }) => {
+          const computedSignature = createHmacToken({
+            method,
+            path,
+            body,
+            timestamp,
+            nonce,
+            secretKey
+          });
+          const isValid = computedSignature === signature;
+          if (!isValid) {
+            const errorInfo = {
+              method,
+              path,
+              timestamp: timestamp.toISOString(),
+              nonce,
+              receivedSignature: signature,
+              computedSignature
+            };
+            openTelemetryCollector?.debug("[HMAC Verification Failed]", {
+              ...errorInfo,
+              bodyType: body ? typeof body : "undefined",
+              body: body ? (0, import_common6.safeStringify)(body) : "undefined"
+            });
+          }
+          return isValid;
+        }
+      }
     };
-    this._pinoLogger[level](...normalizeLogArgs(filteredArgs));
-    const formattedBody = safePrettyFormat(level, filteredArgs);
-    try {
-      import_api_logs.logs.getLogger(process.env.OTEL_SERVICE_NAME ?? "unknown").emit({
-        severityText: level,
-        severityNumber: mapSeverity(level),
-        body: formattedBody,
-        attributes: { ...this._meta, ...meta2 }
-      });
-    } catch (error) {
-      console.error("Failed to emit OpenTelemetry log:", error);
-      console.log(
-        `[${(/* @__PURE__ */ new Date()).toISOString()}] ${level.toUpperCase()}:`,
-        ...filteredArgs
-      );
-    }
-  }
-  error = (msg, ...args) => this.log("error", msg, ...args);
-  info = (msg, ...args) => this.log("info", msg, ...args);
-  debug = (msg, ...args) => this.log("debug", msg, ...args);
-  warn = (msg, ...args) => this.log("warn", msg, ...args);
-  trace = (msg, ...args) => this.log("trace", msg, ...args);
-  child(meta2 = {}) {
-    return new _PinoLogger(this._pinoLogger.level, { ...this._meta, ...meta2 });
   }
-  getBaseLogger() {
-    return this._pinoLogger;
+  if (authMethod == null) {
+    throw new Error("Invalid auth method");
   }
-};
-function logger(level, meta2 = {}) {
-  return new PinoLogger(level, meta2);
+  return authMethod;
+}
+
+// src/http/guards/hasFeatureChecks.ts
+function hasFeatureChecks(maybeFeatureAuth) {
+  return typeof maybeFeatureAuth === "object" && maybeFeatureAuth !== null && "requiredFeatures" in maybeFeatureAuth && Array.isArray(maybeFeatureAuth.requiredFeatures) && maybeFeatureAuth.requiredFeatures.length > 0;
+}
+
+// src/http/guards/hasSubscriptionChecks.ts
+function hasSubscriptionChecks(maybeSubscriptionAuth) {
+  return typeof maybeSubscriptionAuth === "object" && maybeSubscriptionAuth !== null && "requireActiveSubscription" in maybeSubscriptionAuth && maybeSubscriptionAuth.requireActiveSubscription === true;
 }
 
 // src/http/middleware/request/auth.middleware.ts
@@ -863,7 +1037,7 @@ async function checkAuthorizationToken(req, authorizationMethod, authorizationTo
       break;
     }
     default:
-      (0, import_common6.isNever)(type);
+      (0, import_common7.isNever)(type);
       return [401, "Invalid Authorization method."];
   }
   if (isHmacMethod(collapsedAuthorizationMethod) && sessionPayload == null) {
@@ -1003,155 +1177,6 @@ async function parseRequestAuth(req, res, next) {
 
 // src/http/middleware/request/enrichDetails.middleware.ts
 var import_common8 = require("@forklaunch/common");
-
-// src/http/telemetry/openTelemetryCollector.ts
-var import_common7 = require("@forklaunch/common");
-var import_opentelemetry_instrumentation_hyper_express = require("@forklaunch/opentelemetry-instrumentation-hyper-express");
-var import_api3 = require("@opentelemetry/api");
-var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
-var import_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
-var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
-var import_instrumentation_express = require("@opentelemetry/instrumentation-express");
-var import_instrumentation_http = require("@opentelemetry/instrumentation-http");
-var import_resources = require("@opentelemetry/resources");
-var import_sdk_logs = require("@opentelemetry/sdk-logs");
-var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
-var import_sdk_node = require("@opentelemetry/sdk-node");
-var import_semantic_conventions2 = require("@opentelemetry/semantic-conventions");
-var import_dotenv = __toESM(require("dotenv"));
-
-// src/http/guards/isForklaunchRequest.ts
-function isForklaunchRequest(request) {
-  return request != null && typeof request === "object" && "contractDetails" in request;
-}
-
-// src/http/telemetry/openTelemetryCollector.ts
-var OpenTelemetryCollector = class {
-  _logger;
-  _serviceName;
-  _metrics;
-  // scoped creation and create this in middleware when api execute. Also add correlation id
-  constructor(serviceName, level, metricDefinitions) {
-    this._serviceName = serviceName;
-    this._logger = logger(level || "info");
-    this._metrics = {};
-    for (const [metricId, metricType] of Object.entries(
-      metricDefinitions ?? {}
-    )) {
-      switch (metricType) {
-        case "counter":
-          this._metrics[metricId] = import_api3.metrics.getMeter(this._serviceName).createCounter(metricId);
-          break;
-        case "gauge":
-          this._metrics[metricId] = import_api3.metrics.getMeter(this._serviceName).createGauge(metricId);
-          break;
-        case "histogram":
-          this._metrics[metricId] = import_api3.metrics.getMeter(this._serviceName).createHistogram(metricId);
-          break;
-        case "upDownCounter":
-          this._metrics[metricId] = import_api3.metrics.getMeter(this._serviceName).createUpDownCounter(metricId);
-          break;
-        case "observableCounter":
-          this._metrics[metricId] = import_api3.metrics.getMeter(this._serviceName).createObservableCounter(metricId);
-          break;
-        case "observableGauge":
-          this._metrics[metricId] = import_api3.metrics.getMeter(this._serviceName).createObservableGauge(metricId);
-          break;
-        case "observableUpDownCounter":
-          this._metrics[metricId] = import_api3.metrics.getMeter(this._serviceName).createObservableUpDownCounter(metricId);
-          break;
-      }
-    }
-    this.log(
-      "info",
-      "OpenTelemetry Collector (Traces + Logs + Metrics) started"
-    );
-  }
-  log(level, ...args) {
-    this._logger.log(level, ...args);
-  }
-  info = (msg, ...args) => {
-    this._logger.log("info", msg, ...args);
-  };
-  error = (msg, ...args) => {
-    this._logger.log("error", msg, ...args);
-  };
-  warn = (msg, ...args) => {
-    this._logger.log("warn", msg, ...args);
-  };
-  debug = (msg, ...args) => {
-    this._logger.log("debug", msg, ...args);
-  };
-  trace = (msg, ...args) => {
-    this._logger.log("trace", msg, ...args);
-  };
-  getMetric(metricId) {
-    return this._metrics[metricId];
-  }
-};
-import_dotenv.default.config({ path: (0, import_common7.getEnvVar)("DOTENV_FILE_PATH") });
-function parseOtelHeaders() {
-  const headersEnv = (0, import_common7.getEnvVar)("OTEL_EXPORTER_OTLP_HEADERS");
-  if (!headersEnv) return void 0;
-  const headers = {};
-  for (const pair of headersEnv.split(",")) {
-    const [key, ...valueParts] = pair.split("=");
-    if (key && valueParts.length > 0) {
-      headers[key.trim()] = valueParts.join("=").trim();
-    }
-  }
-  return Object.keys(headers).length > 0 ? headers : void 0;
-}
-var otelHeaders = parseOtelHeaders();
-new import_sdk_node.NodeSDK({
-  resource: (0, import_resources.resourceFromAttributes)({
-    [import_semantic_conventions2.ATTR_SERVICE_NAME]: (0, import_common7.getEnvVar)("OTEL_SERVICE_NAME")
-  }),
-  traceExporter: new import_exporter_trace_otlp_http.OTLPTraceExporter({
-    url: `${(0, import_common7.getEnvVar)("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/traces`,
-    headers: otelHeaders
-  }),
-  metricReader: new import_sdk_metrics.PeriodicExportingMetricReader({
-    exporter: new import_exporter_metrics_otlp_http.OTLPMetricExporter({
-      url: `${(0, import_common7.getEnvVar)("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/metrics`,
-      headers: otelHeaders
-    }),
-    exportIntervalMillis: 5e3
-  }),
-  logRecordProcessors: [
-    new import_sdk_logs.BatchLogRecordProcessor(
-      new import_exporter_logs_otlp_http.OTLPLogExporter({
-        url: `${(0, import_common7.getEnvVar)("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/logs`,
-        headers: otelHeaders
-      })
-    )
-  ],
-  instrumentations: [
-    new import_instrumentation_http.HttpInstrumentation({
-      applyCustomAttributesOnSpan: (span, request) => {
-        span.setAttribute(
-          import_semantic_conventions2.ATTR_SERVICE_NAME,
-          (0, import_common7.getEnvVar)("OTEL_SERVICE_NAME") ?? "unknown"
-        );
-        if (isForklaunchRequest(request)) {
-          span.setAttribute(ATTR_API_NAME, request.contractDetails?.name);
-          span.setAttribute(ATTR_CORRELATION_ID, request.context.correlationId);
-        }
-      }
-    }),
-    new import_instrumentation_express.ExpressInstrumentation(),
-    new import_opentelemetry_instrumentation_hyper_express.HyperExpressInstrumentation()
-  ]
-}).start();
-var httpRequestsTotalCounter = import_api3.metrics.getMeter((0, import_common7.getEnvVar)("OTEL_SERVICE_NAME") || "unknown").createCounter("http_requests_total", {
-  description: "Number of HTTP requests"
-});
-var httpServerDurationHistogram = import_api3.metrics.getMeter((0, import_common7.getEnvVar)("OTEL_SERVICE_NAME") || "unknown").createHistogram("http_server_duration", {
-  description: "Duration of HTTP server requests",
-  unit: "s"
-});
-
-// src/http/middleware/request/enrichDetails.middleware.ts
 function enrichDetails(path, contractDetails, requestSchema, responseSchemas, openTelemetryCollector, globalOptions) {
   return (req, res, next) => {
     req.originalPath = path;
@@ -3840,19 +3865,26 @@ var import_stream = require("stream");
 
 // src/http/telemetry/recordMetric.ts
 var import_common13 = require("@forklaunch/common");
-var import_semantic_conventions3 = require("@opentelemetry/semantic-conventions");
+var import_semantic_conventions4 = require("@opentelemetry/semantic-conventions");
 function recordMetric(req, res) {
   if (res.metricRecorded) {
     return;
   }
-  httpRequestsTotalCounter.add(1, {
-    [import_semantic_conventions3.ATTR_SERVICE_NAME]: (0, import_common13.getEnvVar)("OTEL_SERVICE_NAME"),
+  const serviceName = (0, import_common13.getEnvVar)("OTEL_SERVICE_NAME") || "unknown";
+  const attrs = {
+    [import_semantic_conventions4.ATTR_SERVICE_NAME]: serviceName,
     [ATTR_APPLICATION_ID]: (0, import_common13.getEnvVar)("OTEL_APPLICATION_ID"),
     [ATTR_API_NAME]: req.contractDetails?.name,
-    [import_semantic_conventions3.ATTR_HTTP_REQUEST_METHOD]: req.method,
-    [import_semantic_conventions3.ATTR_HTTP_ROUTE]: req.originalPath,
-    [import_semantic_conventions3.ATTR_HTTP_RESPONSE_STATUS_CODE]: Number(res.statusCode) || 0
-  });
+    [import_semantic_conventions4.ATTR_HTTP_REQUEST_METHOD]: req.method,
+    [import_semantic_conventions4.ATTR_HTTP_ROUTE]: req.originalPath,
+    [import_semantic_conventions4.ATTR_HTTP_RESPONSE_STATUS_CODE]: Number(res.statusCode) || 0
+  };
+  httpRequestsTotalCounter.add(1, attrs);
+  const durationMs = req.context?.requestStartTime != null ? Date.now() - req.context.requestStartTime : 0;
+  httpRequestDurationMsHistogram.record(durationMs, attrs);
+  if (Number(res.statusCode) >= 400) {
+    httpErrorsTotalCounter.add(1, attrs);
+  }
   res.metricRecorded = true;
 }
 
@@ -4495,6 +4527,9 @@ var RateLimiter = class {
   getCachedJwks,
   getCodeForStatus,
   head,
+  httpErrorsTotalCounter,
+  httpRequestDurationMsHistogram,
+  httpRequestsInFlightCounter,
   httpRequestsTotalCounter,
   httpServerDurationHistogram,
   isClientError,