@forklaunch/core 1.5.2 → 1.5.4

package/lib/http/index.mjs

@@ -92,8 +92,9 @@ function isTypedHandler(maybeTypedHandler) {
 }
 
 // src/http/middleware/request/createContext.middleware.ts
-import { getEnvVar } from "@forklaunch/common";
-import { context, trace } from "@opentelemetry/api";
+import { getEnvVar as getEnvVar2 } from "@forklaunch/common";
+import { context, trace as trace2 } from "@opentelemetry/api";
+import { ATTR_SERVICE_NAME as OTEL_ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import { v4 } from "uuid";
 
 // src/http/telemetry/constants.ts
@@ -107,6 +108,331 @@ var ATTR_API_NAME = "api.name";
 var ATTR_CORRELATION_ID = "correlation.id";
 var ATTR_APPLICATION_ID = "application_id";
 
+// src/http/telemetry/openTelemetryCollector.ts
+import { getEnvVar } from "@forklaunch/common";
+import { HyperExpressInstrumentation } from "@forklaunch/opentelemetry-instrumentation-hyper-express";
+import {
+  metrics
+} from "@opentelemetry/api";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { ExpressInstrumentation } from "@opentelemetry/instrumentation-express";
+import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import {
+  ATTR_SERVICE_NAME as ATTR_SERVICE_NAME2
+} from "@opentelemetry/semantic-conventions";
+import dotenv from "dotenv";
+
+// src/http/guards/isForklaunchRequest.ts
+function isForklaunchRequest(request) {
+  return request != null && typeof request === "object" && "contractDetails" in request;
+}
+
+// src/http/telemetry/pinoLogger.ts
+import { isNever } from "@forklaunch/common";
+import { trace } from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+import pino from "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:
+      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 = pino({
+      level: level || "info",
+      formatters: {
+        level(label) {
+          return { level: label };
+        }
+      },
+      timestamp: pino.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 = 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 {
+      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] = metrics.getMeter(this._serviceName).createCounter(metricId);
+          break;
+        case "gauge":
+          this._metrics[metricId] = metrics.getMeter(this._serviceName).createGauge(metricId);
+          break;
+        case "histogram":
+          this._metrics[metricId] = metrics.getMeter(this._serviceName).createHistogram(metricId);
+          break;
+        case "upDownCounter":
+          this._metrics[metricId] = metrics.getMeter(this._serviceName).createUpDownCounter(metricId);
+          break;
+        case "observableCounter":
+          this._metrics[metricId] = metrics.getMeter(this._serviceName).createObservableCounter(metricId);
+          break;
+        case "observableGauge":
+          this._metrics[metricId] = metrics.getMeter(this._serviceName).createObservableGauge(metricId);
+          break;
+        case "observableUpDownCounter":
+          this._metrics[metricId] = 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];
+  }
+};
+dotenv.config({ path: getEnvVar("DOTENV_FILE_PATH") });
+function parseOtelHeaders() {
+  const headersEnv = 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 NodeSDK({
+  resource: resourceFromAttributes({
+    [ATTR_SERVICE_NAME2]: getEnvVar("OTEL_SERVICE_NAME")
+  }),
+  traceExporter: new OTLPTraceExporter({
+    url: `${getEnvVar("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/traces`,
+    headers: otelHeaders
+  }),
+  metricReader: new PeriodicExportingMetricReader({
+    exporter: new OTLPMetricExporter({
+      url: `${getEnvVar("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/metrics`,
+      headers: otelHeaders
+    }),
+    exportIntervalMillis: 5e3
+  }),
+  logRecordProcessors: [
+    new BatchLogRecordProcessor({
+      exporter: new OTLPLogExporter({
+        url: `${getEnvVar("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/logs`,
+        headers: otelHeaders
+      })
+    })
+  ],
+  instrumentations: [
+    new HttpInstrumentation({
+      applyCustomAttributesOnSpan: (span, request) => {
+        span.setAttribute(
+          ATTR_SERVICE_NAME2,
+          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 ExpressInstrumentation(),
+    new HyperExpressInstrumentation()
+  ]
+}).start();
+var httpRequestsTotalCounter = metrics.getMeter(getEnvVar("OTEL_SERVICE_NAME") || "unknown").createCounter("http_requests_total", {
+  description: "Number of HTTP requests"
+});
+var httpServerDurationHistogram = metrics.getMeter(getEnvVar("OTEL_SERVICE_NAME") || "unknown").createHistogram("http_server_duration", {
+  description: "Duration of HTTP server requests",
+  unit: "s"
+});
+var httpRequestDurationMsHistogram = metrics.getMeter(getEnvVar("OTEL_SERVICE_NAME") || "unknown").createHistogram("http_request_duration_ms", {
+  description: "Duration of HTTP requests in milliseconds"
+});
+var httpErrorsTotalCounter = metrics.getMeter(getEnvVar("OTEL_SERVICE_NAME") || "unknown").createCounter("http_errors_total", {
+  description: "Total number of HTTP errors (4xx/5xx)"
+});
+var httpRequestsInFlightCounter = metrics.getMeter(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) {
@@ -117,16 +443,30 @@ function createContext(schemaValidator) {
     }
     res.setHeader("x-correlation-id", correlationId);
     req.context = {
-      correlationId
+      correlationId,
+      requestStartTime: Date.now()
+    };
+    const serviceName = getEnvVar2("OTEL_SERVICE_NAME") || "unknown";
+    const inFlightAttrs = {
+      [OTEL_ATTR_SERVICE_NAME]: serviceName
     };
-    const span = trace.getSpan(context.active());
+    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 = trace2.getSpan(context.active());
     if (span != null) {
       req.context.span = span;
       req.context.span?.setAttribute(ATTR_CORRELATION_ID, correlationId);
-      req.context.span?.setAttribute(
-        ATTR_SERVICE_NAME,
-        getEnvVar("OTEL_SERVICE_NAME")
-      );
+      req.context.span?.setAttribute(ATTR_SERVICE_NAME, serviceName);
     }
     next?.();
   };
@@ -387,254 +727,89 @@ 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 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 ? safeStringify2(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
-import { isNever } from "@forklaunch/common";
-import { trace as trace2 } from "@opentelemetry/api";
-import { logs } from "@opentelemetry/api-logs";
-import pino from "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:
-      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 = pino({
-      level: level || "info",
-      formatters: {
-        level(label) {
-          return { level: label };
-        }
-      },
-      timestamp: pino.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 = trace2.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
+      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 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 ? safeStringify2(body) : "undefined"
+            });
+          }
+          return isValid;
+        }
+      }
     };
-    this._pinoLogger[level](...normalizeLogArgs(filteredArgs));
-    const formattedBody = safePrettyFormat(level, filteredArgs);
-    try {
-      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
@@ -927,159 +1102,6 @@ async function parseRequestAuth(req, res, next) {
 
 // src/http/middleware/request/enrichDetails.middleware.ts
 import { getEnvVar as getEnvVar3 } from "@forklaunch/common";
-
-// src/http/telemetry/openTelemetryCollector.ts
-import { getEnvVar as getEnvVar2 } from "@forklaunch/common";
-import { HyperExpressInstrumentation } from "@forklaunch/opentelemetry-instrumentation-hyper-express";
-import {
-  metrics
-} from "@opentelemetry/api";
-import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { ExpressInstrumentation } from "@opentelemetry/instrumentation-express";
-import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import { BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
-import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import {
-  ATTR_SERVICE_NAME as ATTR_SERVICE_NAME2
-} from "@opentelemetry/semantic-conventions";
-import dotenv from "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] = metrics.getMeter(this._serviceName).createCounter(metricId);
-          break;
-        case "gauge":
-          this._metrics[metricId] = metrics.getMeter(this._serviceName).createGauge(metricId);
-          break;
-        case "histogram":
-          this._metrics[metricId] = metrics.getMeter(this._serviceName).createHistogram(metricId);
-          break;
-        case "upDownCounter":
-          this._metrics[metricId] = metrics.getMeter(this._serviceName).createUpDownCounter(metricId);
-          break;
-        case "observableCounter":
-          this._metrics[metricId] = metrics.getMeter(this._serviceName).createObservableCounter(metricId);
-          break;
-        case "observableGauge":
-          this._metrics[metricId] = metrics.getMeter(this._serviceName).createObservableGauge(metricId);
-          break;
-        case "observableUpDownCounter":
-          this._metrics[metricId] = 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];
-  }
-};
-dotenv.config({ path: getEnvVar2("DOTENV_FILE_PATH") });
-function parseOtelHeaders() {
-  const headersEnv = getEnvVar2("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 NodeSDK({
-  resource: resourceFromAttributes({
-    [ATTR_SERVICE_NAME2]: getEnvVar2("OTEL_SERVICE_NAME")
-  }),
-  traceExporter: new OTLPTraceExporter({
-    url: `${getEnvVar2("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/traces`,
-    headers: otelHeaders
-  }),
-  metricReader: new PeriodicExportingMetricReader({
-    exporter: new OTLPMetricExporter({
-      url: `${getEnvVar2("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/metrics`,
-      headers: otelHeaders
-    }),
-    exportIntervalMillis: 5e3
-  }),
-  logRecordProcessors: [
-    new BatchLogRecordProcessor(
-      new OTLPLogExporter({
-        url: `${getEnvVar2("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/logs`,
-        headers: otelHeaders
-      })
-    )
-  ],
-  instrumentations: [
-    new HttpInstrumentation({
-      applyCustomAttributesOnSpan: (span, request) => {
-        span.setAttribute(
-          ATTR_SERVICE_NAME2,
-          getEnvVar2("OTEL_SERVICE_NAME") ?? "unknown"
-        );
-        if (isForklaunchRequest(request)) {
-          span.setAttribute(ATTR_API_NAME, request.contractDetails?.name);
-          span.setAttribute(ATTR_CORRELATION_ID, request.context.correlationId);
-        }
-      }
-    }),
-    new ExpressInstrumentation(),
-    new HyperExpressInstrumentation()
-  ]
-}).start();
-var httpRequestsTotalCounter = metrics.getMeter(getEnvVar2("OTEL_SERVICE_NAME") || "unknown").createCounter("http_requests_total", {
-  description: "Number of HTTP requests"
-});
-var httpServerDurationHistogram = metrics.getMeter(getEnvVar2("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;
@@ -3789,14 +3811,21 @@ function recordMetric(req, res) {
   if (res.metricRecorded) {
     return;
   }
-  httpRequestsTotalCounter.add(1, {
-    [ATTR_SERVICE_NAME3]: getEnvVar4("OTEL_SERVICE_NAME"),
+  const serviceName = getEnvVar4("OTEL_SERVICE_NAME") || "unknown";
+  const attrs = {
+    [ATTR_SERVICE_NAME3]: serviceName,
     [ATTR_APPLICATION_ID]: getEnvVar4("OTEL_APPLICATION_ID"),
     [ATTR_API_NAME]: req.contractDetails?.name,
     [ATTR_HTTP_REQUEST_METHOD3]: req.method,
     [ATTR_HTTP_ROUTE3]: req.originalPath,
     [ATTR_HTTP_RESPONSE_STATUS_CODE3]: 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;
 }
 
@@ -4438,6 +4467,9 @@ export {
   getCachedJwks,
   getCodeForStatus,
   head,
+  httpErrorsTotalCounter,
+  httpRequestDurationMsHistogram,
+  httpRequestsInFlightCounter,
   httpRequestsTotalCounter,
   httpServerDurationHistogram,
   isClientError,