@forklaunch/core 0.4.0 → 0.5.1

package/lib/http/index.js

@@ -30,12 +30,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/http/index.ts
 var http_exports = {};
 __export(http_exports, {
+  ATTR_API_NAME: () => ATTR_API_NAME,
+  ATTR_CORRELATION_ID: () => ATTR_CORRELATION_ID,
+  ATTR_HTTP_REQUEST_METHOD: () => import_semantic_conventions.ATTR_HTTP_REQUEST_METHOD,
+  ATTR_HTTP_RESPONSE_STATUS_CODE: () => import_semantic_conventions.ATTR_HTTP_RESPONSE_STATUS_CODE,
+  ATTR_HTTP_ROUTE: () => import_semantic_conventions.ATTR_HTTP_ROUTE,
+  ATTR_SERVICE_NAME: () => import_semantic_conventions.ATTR_SERVICE_NAME,
   ForklaunchExpressLikeApplication: () => ForklaunchExpressLikeApplication,
   ForklaunchExpressLikeRouter: () => ForklaunchExpressLikeRouter,
   HTTPStatuses: () => HTTPStatuses,
   OpenTelemetryCollector: () => OpenTelemetryCollector,
   delete_: () => delete_,
-  emitLoggerError: () => emitLoggerError,
   enrichExpressLikeSend: () => enrichExpressLikeSend,
   generateSwaggerDocument: () => generateSwaggerDocument,
   get: () => get,
@@ -43,19 +48,22 @@ __export(http_exports, {
   head: () => head,
   httpRequestsTotalCounter: () => httpRequestsTotalCounter,
   isClientError: () => isClientError,
+  isForklaunchRequest: () => isForklaunchRequest,
   isForklaunchRouter: () => isForklaunchRouter,
   isInformational: () => isInformational,
   isRedirection: () => isRedirection,
   isServerError: () => isServerError,
   isSuccessful: () => isSuccessful,
   isValidStatusCode: () => isValidStatusCode,
+  logger: () => logger,
+  metricsDefinitions: () => metricsDefinitions,
   middleware: () => middleware,
   options: () => options,
   patch: () => patch,
   post: () => post,
   put: () => put,
   recordMetric: () => recordMetric,
-  trace: () => trace,
+  trace: () => trace2,
   typedHandler: () => typedHandler
 });
 module.exports = __toCommonJS(http_exports);
@@ -71,7 +79,15 @@ function cors(req, res, next) {
 }
 
 // src/http/middleware/request/createContext.middleware.ts
+var import_api = require("@opentelemetry/api");
 var import_uuid = require("uuid");
+
+// src/http/telemetry/constants.ts
+var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+var ATTR_API_NAME = "api.name";
+var ATTR_CORRELATION_ID = "correlation.id";
+
+// src/http/middleware/request/createContext.middleware.ts
 function createContext(schemaValidator) {
   return function setContext(req, res, next) {
     req.schemaValidator = schemaValidator;
@@ -83,6 +99,11 @@ function createContext(schemaValidator) {
     req.context = {
       correlationId
     };
+    const span = import_api.trace.getActiveSpan();
+    if (span != null) {
+      req.context.span = span;
+      req.context.span?.setAttribute(ATTR_CORRELATION_ID, correlationId);
+    }
     next?.();
   };
 }
@@ -268,6 +289,7 @@ function enrichDetails(path, contractDetails, requestSchema, responseSchemas) {
     req.contractDetails = contractDetails;
     req.requestSchema = requestSchema;
     res.responseSchemas = responseSchemas;
+    req.context.span?.setAttribute(ATTR_API_NAME, req.contractDetails?.name);
     next?.();
   };
 }
@@ -288,7 +310,10 @@ function parse(req, _res, next) {
     headers: req.headers,
     body: req.body
   };
-  const parsedRequest = req.schemaValidator.parse(req.requestSchema, request);
+  const parsedRequest = req.schemaValidator.parse(
+    req.requestSchema,
+    request
+  );
   if (parsedRequest.ok && isResponseShape(parsedRequest.value)) {
     req.body = parsedRequest.value.body;
     req.params = parsedRequest.value.params;
@@ -362,7 +387,7 @@ var ForklaunchExpressLikeRouter = class {
       try {
         await requestHandler(req, res, next);
       } catch (error) {
-        if (next) {
+        if (next && typeof next === "function") {
           next(error);
         } else {
           throw error;
@@ -398,7 +423,7 @@ var ForklaunchExpressLikeRouter = class {
         ...contractDetails.params ? { params: contractDetails.params } : {},
         ...contractDetails.requestHeaders ? { headers: contractDetails.requestHeaders } : {},
         ...contractDetails.query ? { query: contractDetails.query } : {},
-        ...isHttpContractDetails(contractDetails) && contractDetails.body ? { body: contractDetails.body } : {}
+        ...isHttpContractDetails(contractDetails) && contractDetails.body != null ? { body: contractDetails.body } : {}
       })
     );
     const responseEntries = {
@@ -407,7 +432,9 @@ var ForklaunchExpressLikeRouter = class {
       403: schemaValidator.string,
       404: schemaValidator.string,
       500: schemaValidator.string,
-      ...isPathParamHttpContractDetails(contractDetails) || isHttpContractDetails(contractDetails) ? { ...contractDetails.responses } : {}
+      ...isPathParamHttpContractDetails(contractDetails) || isHttpContractDetails(contractDetails) ? {
+        ...contractDetails.responses
+      } : {}
     };
     const responseSchemas = {
       responses: {},
@@ -537,9 +564,12 @@ var ForklaunchExpressLikeRouter = class {
         const controllerHandler = this.#extractControllerHandler(handlers);
         registrationMethod.bind(this.internal)(
           path,
-          ...this.#resolveMiddlewares(path, contractDetails, requestSchema, responseSchemas).concat(
-            handlers
-          ),
+          ...this.#resolveMiddlewares(
+            path,
+            contractDetails,
+            requestSchema,
+            responseSchemas
+          ).concat(handlers),
           this.#parseAndRunControllerHandler(controllerHandler)
         );
         return this.#localParamRequest(
@@ -595,9 +625,7 @@ var ForklaunchExpressLikeRouter = class {
       contractDetailsOrMiddlewareOrTypedHandler,
       middleware2
     );
-    if (isForklaunchExpressLikeRouter(
-      contractDetailsOrMiddlewareOrTypedHandler
-    )) {
+    if (isForklaunchExpressLikeRouter(contractDetailsOrMiddlewareOrTypedHandler)) {
       middleware2.push(contractDetailsOrMiddlewareOrTypedHandler.internal);
     }
     middleware2.push(
@@ -903,8 +931,18 @@ var ForklaunchExpressLikeApplication = class extends ForklaunchExpressLikeRouter
   }
 };
 
+// src/http/guards/isForklaunchRequest.ts
+function isForklaunchRequest(request) {
+  return request != null && typeof request === "object" && "contractDetails" in request;
+}
+
+// src/http/guards/isPath.ts
+function isPath(path) {
+  return path.startsWith("/");
+}
+
 // src/http/handlers/typedHandler.ts
-function typedHandler(_schemaValidator, _pathOrContractDetails, contractMethodOrContractDetails, contractDetailsOrHandler, ...handlerArray) {
+function typedHandler(_schemaValidator, pathOrContractMethod, contractMethodOrContractDetails, contractDetailsOrHandler, ...handlerArray) {
   let contractDetails;
   let handlers;
   if (typeof contractMethodOrContractDetails === "string") {
@@ -924,6 +962,7 @@ function typedHandler(_schemaValidator, _pathOrContractDetails, contractMethodOr
   }
   return {
     _typedHandler: true,
+    _path: isPath(pathOrContractMethod) ? pathOrContractMethod : void 0,
     contractDetails,
     handlers
   };
@@ -970,11 +1009,11 @@ var put = (_schemaValidator, path, contractDetails, ...handlers) => {
 };
 
 // src/http/handlers/trace.ts
-var trace = (_schemaValidator, path, contractDetails, ...handlers) => {
+var trace2 = (_schemaValidator, path, contractDetails, ...handlers) => {
   return typedHandler(_schemaValidator, path, "trace", contractDetails, ...handlers);
 };
 
-// src/http/utils/httpStatusCodes.ts
+// src/http/httpStatusCodes.ts
 var HTTPStatuses = {
   /**
    * The initial part of a request has been received and has not yet been
@@ -1957,6 +1996,311 @@ var getCodeForStatus = (status) => {
 };
 var httpStatusCodes_default = HTTPStatuses;
 
+// src/http/middleware/response/parse.middleware.ts
+var import_validator2 = require("@forklaunch/validator");
+function parse2(req, res, next) {
+  const { headers, responses } = res.responseSchemas;
+  const parsedResponse = req.schemaValidator.parse(
+    responses?.[res.statusCode],
+    res.bodyData
+  );
+  const parsedHeaders = req.schemaValidator.parse(
+    headers ?? req.schemaValidator.unknown,
+    res.getHeaders()
+  );
+  const parseErrors = [];
+  if (!parsedHeaders.ok) {
+    const headerErrors = (0, import_validator2.prettyPrintParseErrors)(parsedHeaders.errors, "Header");
+    if (headerErrors) {
+      parseErrors.push(headerErrors);
+    }
+  }
+  if (!parsedResponse.ok) {
+    const responseErrors = (0, import_validator2.prettyPrintParseErrors)(
+      parsedResponse.errors,
+      "Response"
+    );
+    if (responseErrors) {
+      parseErrors.push(responseErrors);
+    }
+  }
+  if (parseErrors.length > 0) {
+    switch (req.contractDetails.options?.responseValidation) {
+      default:
+      case "error":
+        next?.(new Error(`Invalid response:
+${parseErrors.join("\n\n")}`));
+        break;
+      case "warning":
+        console.warn(`Invalid response:
+${parseErrors.join("\n\n")}`);
+        break;
+      case "none":
+        break;
+    }
+  }
+  next?.();
+}
+
+// src/http/telemetry/pinoLogger.ts
+var import_common2 = require("@forklaunch/common");
+var import_api2 = require("@opentelemetry/api");
+var import_api_logs = require("@opentelemetry/api-logs");
+var import_pino = __toESM(require("pino"));
+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;
+  }
+}
+var PinoLogger = class _PinoLogger {
+  pinoLogger;
+  meta;
+  constructor(level, meta = {}) {
+    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 }
+      }
+    });
+    this.meta = meta;
+  }
+  log(level, msg, meta = {}) {
+    const activeSpan = import_api2.trace.getActiveSpan();
+    if (activeSpan) {
+      const activeSpanContext = activeSpan.spanContext();
+      meta.trace_id = activeSpanContext.traceId;
+      meta.span_id = activeSpanContext.spanId;
+      meta.trace_flags = activeSpanContext.traceFlags;
+      if (!meta.api_name) {
+        meta = { ...meta, ...activeSpan?.attributes };
+      }
+    }
+    this.pinoLogger[level](msg);
+    import_api_logs.logs.getLogger(process.env.OTEL_SERVICE_NAME ?? "unknown").emit({
+      severityText: level,
+      severityNumber: mapSeverity(level),
+      body: msg,
+      attributes: { ...this.meta, ...meta }
+    });
+  }
+  error(msg, meta = {}) {
+    this.log("error", msg, meta);
+  }
+  info(msg, meta = {}) {
+    this.log("info", msg, meta);
+  }
+  debug(msg, meta = {}) {
+    this.log("debug", msg, meta);
+  }
+  warn(msg, meta = {}) {
+    this.log("warn", msg, meta);
+  }
+  trace(msg, meta = {}) {
+    this.log("trace", msg, meta);
+  }
+  child(meta = {}) {
+    return new _PinoLogger(this.pinoLogger.level, { ...this.meta, ...meta });
+  }
+  getBaseLogger() {
+    return this.pinoLogger;
+  }
+};
+function logger(level, meta = {}) {
+  return new PinoLogger(level, meta);
+}
+
+// src/http/telemetry/recordMetric.ts
+var import_semantic_conventions3 = require("@opentelemetry/semantic-conventions");
+
+// src/services/configInjector.ts
+var import_common3 = require("@forklaunch/common");
+var import_validator3 = require("@forklaunch/validator");
+
+// src/services/getEnvVar.ts
+function getEnvVar(name) {
+  const value = process.env[name];
+  return value;
+}
+
+// src/http/telemetry/openTelemetryCollector.ts
+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"));
+var OpenTelemetryCollector = class {
+  // 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 (Traces + Logs + Metrics) started");
+  }
+  logger;
+  metrics;
+  log(level, msg, meta = {}) {
+    this.logger.log(level, msg, meta);
+  }
+  info(msg, meta = {}) {
+    this.logger.info(msg, meta);
+  }
+  error(msg, meta = {}) {
+    this.logger.error(msg, meta);
+  }
+  warn(msg, meta = {}) {
+    this.logger.warn(msg, meta);
+  }
+  debug(msg, meta = {}) {
+    this.logger.debug(msg, meta);
+  }
+  trace(msg, meta = {}) {
+    this.logger.trace(msg, meta);
+  }
+  getMetric(metricId) {
+    return this.metrics[metricId];
+  }
+};
+import_dotenv.default.config({ path: getEnvVar("ENV_FILE_PATH") });
+new import_sdk_node.NodeSDK({
+  resource: new import_resources.Resource({
+    [import_semantic_conventions2.ATTR_SERVICE_NAME]: getEnvVar("OTEL_SERVICE_NAME")
+  }),
+  traceExporter: new import_exporter_trace_otlp_http.OTLPTraceExporter({
+    url: `${getEnvVar("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/traces`
+  }),
+  metricReader: new import_sdk_metrics.PeriodicExportingMetricReader({
+    exporter: new import_exporter_metrics_otlp_http.OTLPMetricExporter({
+      url: `${getEnvVar("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/metrics`
+    }),
+    exportIntervalMillis: 5e3
+  }),
+  logRecordProcessors: [
+    new import_sdk_logs.BatchLogRecordProcessor(
+      new import_exporter_logs_otlp_http.OTLPLogExporter({
+        url: `${getEnvVar("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/logs`
+      })
+    )
+  ],
+  instrumentations: [
+    new import_instrumentation_http.HttpInstrumentation({
+      applyCustomAttributesOnSpan: (span, request) => {
+        span.setAttribute(
+          "service.name",
+          getEnvVar("OTEL_SERVICE_NAME") ?? "unknown"
+        );
+        if (isForklaunchRequest(request)) {
+          span.setAttribute("api.name", request.contractDetails?.name);
+        }
+      }
+    }),
+    new import_instrumentation_express.ExpressInstrumentation(),
+    new import_opentelemetry_instrumentation_hyper_express.HyperExpressInstrumentation()
+  ]
+}).start();
+var httpRequestsTotalCounter = import_api3.metrics.getMeter(getEnvVar("OTEL_SERVICE_NAME") || "unknown").createCounter("http_requests_total", {
+  description: "Number of HTTP requests"
+});
+
+// src/http/telemetry/recordMetric.ts
+function recordMetric(req, res) {
+  httpRequestsTotalCounter.add(1, {
+    [import_semantic_conventions3.ATTR_SERVICE_NAME]: getEnvVar("OTEL_SERVICE_NAME"),
+    [ATTR_API_NAME]: req.contractDetails?.name,
+    [ATTR_CORRELATION_ID]: req.context.correlationId,
+    [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]: res.statusCode || 0
+  });
+}
+
+// src/http/middleware/response/enrichExpressLikeSend.middleware.ts
+function enrichExpressLikeSend(instance, req, res, originalSend, data, shouldEnrich) {
+  let parseErrorSent;
+  if (shouldEnrich) {
+    recordMetric(req, res);
+    if (res.statusCode === 404) {
+      res.status(404);
+      logger("error").error("Not Found");
+      originalSend.call(instance, "Not Found");
+    }
+    parse2(req, res, (err) => {
+      if (err) {
+        let errorString = err.message;
+        if (res.locals.errorMessage) {
+          errorString += `
+------------------
+${res.locals.errorMessage}`;
+        }
+        logger("error").error(errorString);
+        res.status(500);
+        originalSend.call(instance, errorString);
+        parseErrorSent = true;
+      }
+    });
+  }
+  if (!parseErrorSent) {
+    originalSend.call(instance, data);
+  }
+}
+
 // src/http/openApiV3Generator/openApiV3Generator.ts
 function toUpperCase(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
@@ -2100,252 +2444,23 @@ function generateSwaggerDocument(schemaValidator, port, routers) {
   return generateOpenApiDocument(port, tags, paths);
 }
 
-// src/http/tracing/emitLoggerError.ts
-var import_api_logs = require("@opentelemetry/api-logs");
-var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
-
-// src/http/tracing/pinoLogger.ts
-var import_pino = __toESM(require("pino"));
-function pinoLogger(level) {
-  return (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 }
-    }
-  });
-}
-
-// src/http/tracing/emitLoggerError.ts
-var logger = pinoLogger("error");
-var emitLoggerError = (req, res, errorString) => {
-  import_api_logs.logs.getLogger(process.env.SERVICE_NAME ?? "unknown").emit({
-    severityText: "ERROR",
-    severityNumber: 17,
-    body: errorString,
-    attributes: {
-      "service.name": process.env.SERVICE_NAME,
-      "api.name": req.contractDetails?.name,
-      [import_semantic_conventions.SEMATTRS_HTTP_TARGET]: req.path,
-      [import_semantic_conventions.SEMATTRS_HTTP_ROUTE]: req.originalPath,
-      [import_semantic_conventions.SEMATTRS_HTTP_METHOD]: req.method,
-      [import_semantic_conventions.SEMATTRS_HTTP_STATUS_CODE]: res.statusCode
-    }
-  });
-  logger.error(errorString);
-};
-
-// src/http/tracing/openTelemetryCollector.ts
-var import_opentelemetry_instrumentation_hyper_express = require("@forklaunch/opentelemetry-instrumentation-hyper-express");
-var import_api = require("@opentelemetry/api");
-var import_api_logs2 = require("@opentelemetry/api-logs");
-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 OpenTelemetryCollector = class {
-  // scoped creation and create this in middleware when api execute. Also add correlation id
-  constructor(serviceName, level, metricDefinitions) {
-    this.serviceName = serviceName;
-    this.logger = pinoLogger(level ?? "info");
-    this.metrics = {};
-    for (const [metricId, metricType] of Object.entries(
-      metricDefinitions ?? {}
-    )) {
-      switch (metricType) {
-        case "counter":
-          this.metrics[metricId] = import_api.metrics.getMeter(this.serviceName).createCounter(metricId);
-          break;
-        case "gauge":
-          this.metrics[metricId] = import_api.metrics.getMeter(this.serviceName).createGauge(metricId);
-          break;
-        case "histogram":
-          this.metrics[metricId] = import_api.metrics.getMeter(this.serviceName).createHistogram(metricId);
-          break;
-        case "upDownCounter":
-          this.metrics[metricId] = import_api.metrics.getMeter(this.serviceName).createUpDownCounter(metricId);
-          break;
-        case "observableCounter":
-          this.metrics[metricId] = import_api.metrics.getMeter(this.serviceName).createObservableCounter(metricId);
-          break;
-        case "observableGauge":
-          this.metrics[metricId] = import_api.metrics.getMeter(this.serviceName).createObservableGauge(metricId);
-          break;
-        case "observableUpDownCounter":
-          this.metrics[metricId] = import_api.metrics.getMeter(this.serviceName).createObservableUpDownCounter(metricId);
-          break;
-      }
-    }
-    this.log("info", "OpenTelemetry (Traces + Logs + Metrics) started");
-  }
-  logger;
-  metrics;
-  log(level, msg, meta = {}) {
-    const activeSpan = import_api.trace.getActiveSpan();
-    if (activeSpan) {
-      const activeSpanContext = activeSpan.spanContext();
-      meta.trace_id = activeSpanContext.traceId;
-      meta.span_id = activeSpanContext.spanId;
-      meta.trace_flags = activeSpanContext.traceFlags;
-    }
-    if (!meta.api_name) {
-      meta.api_name = activeSpan?.attributes["api.name"] ?? "undefined";
-    }
-    this.logger[level](msg);
-    import_api_logs2.logs.getLogger(this.serviceName).emit({
-      severityText: level,
-      body: msg,
-      attributes: meta
-    });
-  }
-  getMetric(metricId) {
-    return this.metrics[metricId];
-  }
-};
-new import_sdk_node.NodeSDK({
-  resource: new import_resources.Resource({
-    [import_semantic_conventions2.ATTR_SERVICE_NAME]: process.env.SERVICE_NAME
-  }),
-  traceExporter: new import_exporter_trace_otlp_http.OTLPTraceExporter({
-    url: `${process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://localhost:4318"}/v1/traces`
-  }),
-  metricReader: new import_sdk_metrics.PeriodicExportingMetricReader({
-    exporter: new import_exporter_metrics_otlp_http.OTLPMetricExporter({
-      url: `${process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://localhost:4318"}/v1/metrics`
-    }),
-    exportIntervalMillis: 5e3
-  }),
-  logRecordProcessors: [
-    new import_sdk_logs.BatchLogRecordProcessor(
-      new import_exporter_logs_otlp_http.OTLPLogExporter({
-        url: `${process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://localhost:4318"}/v1/logs`
-      })
-    )
-  ],
-  instrumentations: [
-    new import_instrumentation_http.HttpInstrumentation(),
-    new import_instrumentation_express.ExpressInstrumentation({
-      requestHook: (span, info) => {
-        span.setAttribute(
-          "service.name",
-          process.env.SERVICE_NAME ?? "unknown"
-        );
-        span.setAttribute("api.name", info.request.contractDetails?.name);
-      }
-    }),
-    new import_opentelemetry_instrumentation_hyper_express.HyperExpressInstrumentation()
-  ]
-}).start();
-var httpRequestsTotalCounter = import_api.metrics.getMeter(process.env.SERVICE_NAME || "unknown").createCounter("http_requests_total", {
-  description: "Number of HTTP requests"
-});
-
-// src/http/middleware/response/parse.middleware.ts
-var import_validator2 = require("@forklaunch/validator");
-function parse2(req, res, next) {
-  const { headers, responses } = res.responseSchemas;
-  const parsedResponse = req.schemaValidator.parse(
-    responses?.[res.statusCode],
-    res.bodyData
-  );
-  const parsedHeaders = req.schemaValidator.parse(
-    headers ?? req.schemaValidator.unknown,
-    res.getHeaders()
-  );
-  const parseErrors = [];
-  if (!parsedHeaders.ok) {
-    const headerErrors = (0, import_validator2.prettyPrintParseErrors)(parsedHeaders.errors, "Header");
-    if (headerErrors) {
-      parseErrors.push(headerErrors);
-    }
-  }
-  if (!parsedResponse.ok) {
-    const responseErrors = (0, import_validator2.prettyPrintParseErrors)(
-      parsedResponse.errors,
-      "Response"
-    );
-    if (responseErrors) {
-      parseErrors.push(responseErrors);
-    }
-  }
-  if (parseErrors.length > 0) {
-    switch (req.contractDetails.options?.responseValidation) {
-      default:
-      case "error":
-        next?.(new Error(`Invalid response:
-${parseErrors.join("\n\n")}`));
-        break;
-      case "warning":
-        console.warn(`Invalid response:
-${parseErrors.join("\n\n")}`);
-        break;
-      case "none":
-        break;
-    }
-  }
-  next?.();
-}
-
-// src/http/utils/enrichExpressLikeSend.ts
-function enrichExpressLikeSend(instance, req, res, originalSend, data, shouldEnrich) {
-  let parseErrorSent;
-  if (shouldEnrich) {
-    if (res.statusCode === 404) {
-      res.status(404);
-      emitLoggerError(req, res, "Not Found");
-      originalSend.call(instance, "Not Found");
-    }
-    parse2(req, res, (err) => {
-      if (err) {
-        let errorString = err.message;
-        if (res.locals.errorMessage) {
-          errorString += `
-------------------
-${res.locals.errorMessage}`;
-        }
-        emitLoggerError(req, res, errorString);
-        res.status(500);
-        originalSend.call(instance, errorString);
-        parseErrorSent = true;
-      }
-    });
-  }
-  if (!parseErrorSent) {
-    originalSend.call(instance, data);
-  }
-}
-
-// src/http/utils/recordMetric.ts
-var import_semantic_conventions3 = require("@opentelemetry/semantic-conventions");
-function recordMetric(req, res) {
-  httpRequestsTotalCounter.add(1, {
-    "service.name": process.env.SERVICE_NAME ?? "unknown",
-    "api.name": req.contractDetails?.name,
-    [import_semantic_conventions3.SEMATTRS_HTTP_METHOD]: req.method,
-    [import_semantic_conventions3.SEMATTRS_HTTP_ROUTE]: req.originalPath,
-    [import_semantic_conventions3.SEMATTRS_HTTP_STATUS_CODE]: res.statusCode || 0
-  });
+// src/http/telemetry/metricsDefinition.ts
+function metricsDefinitions(metrics2) {
+  return metrics2;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ATTR_API_NAME,
+  ATTR_CORRELATION_ID,
+  ATTR_HTTP_REQUEST_METHOD,
+  ATTR_HTTP_RESPONSE_STATUS_CODE,
+  ATTR_HTTP_ROUTE,
+  ATTR_SERVICE_NAME,
   ForklaunchExpressLikeApplication,
   ForklaunchExpressLikeRouter,
   HTTPStatuses,
   OpenTelemetryCollector,
   delete_,
-  emitLoggerError,
   enrichExpressLikeSend,
   generateSwaggerDocument,
   get,
@@ -2353,12 +2468,15 @@ function recordMetric(req, res) {
   head,
   httpRequestsTotalCounter,
   isClientError,
+  isForklaunchRequest,
   isForklaunchRouter,
   isInformational,
   isRedirection,
   isServerError,
   isSuccessful,
   isValidStatusCode,
+  logger,
+  metricsDefinitions,
   middleware,
   options,
   patch,