@forklaunch/core 0.3.6 → 0.4.0

package/lib/http/index.mjs

@@ -1,3 +1,30 @@
+// src/http/middleware/request/cors.middleware.ts
+import corsMiddleware from "cors";
+function cors(req, res, next) {
+  if (req.method === "OPTIONS") {
+    res.cors = true;
+  }
+  corsMiddleware()(req, res, next ?? (() => {
+  }));
+}
+
+// src/http/middleware/request/createContext.middleware.ts
+import { v4 } from "uuid";
+function createContext(schemaValidator) {
+  return function setContext(req, res, next) {
+    req.schemaValidator = schemaValidator;
+    let correlationId = v4();
+    if (req.headers["x-correlation-id"]) {
+      correlationId = req.headers["x-correlation-id"];
+    }
+    res.setHeader("x-correlation-id", correlationId);
+    req.context = {
+      correlationId
+    };
+    next?.();
+  };
+}
+
 // src/http/guards/isForklaunchRouter.ts
 function isForklaunchRouter(maybeForklaunchRouter) {
   return maybeForklaunchRouter != null && typeof maybeForklaunchRouter === "object" && "basePath" in maybeForklaunchRouter && "routes" in maybeForklaunchRouter && Array.isArray(maybeForklaunchRouter.routes);
@@ -157,55 +184,25 @@ async function checkAuthorizationToken(authorizationMethod, authorizationToken,
   return [401, "Invalid Authorization method."];
 }
 async function parseRequestAuth(req, res, next) {
-  console.debug("[MIDDLEWARE] parseRequest started");
   const auth = req.contractDetails.auth;
   if (auth) {
-    const errorAndMessage = await checkAuthorizationToken(
+    const [error, message] = await checkAuthorizationToken(
       auth,
       req.headers[(auth.method === "other" ? auth.headerName : void 0) ?? "Authorization"],
       req
-    );
-    if (Array.isArray(errorAndMessage)) {
-      res.status(errorAndMessage[0]).send(errorAndMessage[1]);
-      next?.(new Error(errorAndMessage[1]));
+    ) ?? [];
+    if (error != null) {
+      res.status(error).send(message);
+      next?.(new Error(message));
     }
   }
   next?.();
 }
 
-// src/http/middleware/request/cors.middleware.ts
-import corsMiddleware from "cors";
-function cors(req, res, next) {
-  console.debug("[MIDDLEWARE] cors started");
-  if (req.method === "OPTIONS") {
-    res.cors = true;
-  }
-  corsMiddleware()(req, res, next ?? (() => {
-  }));
-}
-
-// src/http/middleware/request/createContext.middleware.ts
-import { v4 } from "uuid";
-function createContext(schemaValidator) {
-  return (req, res, next) => {
-    console.debug("[MIDDLEWARE] createRequestContext started");
-    req.schemaValidator = schemaValidator;
-    let correlationId = v4();
-    if (req.headers["x-correlation-id"]) {
-      correlationId = req.headers["x-correlation-id"];
-    }
-    res.setHeader("x-correlation-id", correlationId);
-    req.context = {
-      correlationId
-    };
-    next?.();
-  };
-}
-
 // src/http/middleware/request/enrichDetails.middleware.ts
-function enrichDetails(contractDetails, requestSchema, responseSchemas) {
+function enrichDetails(path, contractDetails, requestSchema, responseSchemas) {
   return (req, res, next) => {
-    console.debug("[MIDDLEWARE] enrichRequestDetails started");
+    req.originalPath = path;
     req.contractDetails = contractDetails;
     req.requestSchema = requestSchema;
     res.responseSchemas = responseSchemas;
@@ -225,7 +222,6 @@ function isResponseShape(maybeResponseShape) {
 
 // src/http/middleware/request/parse.middleware.ts
 function parse(req, _res, next) {
-  console.debug("[MIDDLEWARE] parseRequest started");
   const request = {
     params: req.params,
     query: req.query,
@@ -263,8 +259,6 @@ var ForklaunchExpressLikeRouter = class {
     this.schemaValidator = schemaValidator;
     this.internal = internal;
     this.basePath = basePath;
-    this.internal.use(createContext(this.schemaValidator));
-    this.internal.use(cors);
   }
   requestHandler;
   routers = [];
@@ -276,9 +270,14 @@ var ForklaunchExpressLikeRouter = class {
    * @param {PathParamHttpContractDetails<SV> | HttpContractDetails<SV>} contractDetails - The contract details.
    * @returns {MiddlewareHandler<SV>[]} - The resolved middlewares.
    */
-  #resolveMiddlewares(contractDetails, requestSchema, responseSchemas) {
+  #resolveMiddlewares(path, contractDetails, requestSchema, responseSchemas) {
     return [
-      enrichDetails(contractDetails, requestSchema, responseSchemas),
+      enrichDetails(
+        `${this.basePath}${path}`,
+        contractDetails,
+        requestSchema,
+        responseSchemas
+      ),
       parse,
       parseRequestAuth
     ];
@@ -303,10 +302,10 @@ var ForklaunchExpressLikeRouter = class {
       try {
         await requestHandler(req, res, next);
       } catch (error) {
-        next?.(error);
-        console.error(error);
-        if (!res.headersSent) {
-          res.status(500).send("Internal Server Error");
+        if (next) {
+          next(error);
+        } else {
+          throw error;
         }
       }
     };
@@ -478,7 +477,7 @@ var ForklaunchExpressLikeRouter = class {
         const controllerHandler = this.#extractControllerHandler(handlers);
         registrationMethod.bind(this.internal)(
           path,
-          ...this.#resolveMiddlewares(contractDetails, requestSchema, responseSchemas).concat(
+          ...this.#resolveMiddlewares(path, contractDetails, requestSchema, responseSchemas).concat(
             handlers
           ),
           this.#parseAndRunControllerHandler(controllerHandler)
@@ -839,6 +838,8 @@ var ForklaunchExpressLikeApplication = class extends ForklaunchExpressLikeRouter
     super("/", schemaValidator, internal);
     this.schemaValidator = schemaValidator;
     this.internal = internal;
+    this.internal.use(createContext(this.schemaValidator));
+    this.internal.use(cors);
   }
 };
 
@@ -1906,7 +1907,7 @@ function transformBasePath(basePath) {
   }
   return `/${basePath}`;
 }
-function swaggerDocument(port, tags, paths) {
+function generateOpenApiDocument(port, tags, paths) {
   return {
     openapi: "3.1.0",
     info: {
@@ -1978,7 +1979,10 @@ function generateSwaggerDocument(schemaValidator, port, routers) {
         for (const key in route.contractDetails.params) {
           pathItemObject.parameters?.push({
             name: key,
-            in: "path"
+            in: "path",
+            schema: schemaValidator.openapi(
+              route.contractDetails.params[key]
+            )
           });
         }
       }
@@ -1993,7 +1997,10 @@ function generateSwaggerDocument(schemaValidator, port, routers) {
         for (const key in requestHeaders) {
           pathItemObject.parameters?.push({
             name: key,
-            in: "header"
+            in: "header",
+            schema: schemaValidator.openapi(
+              requestHeaders[key]
+            )
           });
         }
       }
@@ -2001,7 +2008,8 @@ function generateSwaggerDocument(schemaValidator, port, routers) {
         for (const key in query) {
           pathItemObject.parameters?.push({
             name: key,
-            in: "query"
+            in: "query",
+            schema: schemaValidator.openapi(query[key])
           });
         }
       }
@@ -2029,15 +2037,176 @@ function generateSwaggerDocument(schemaValidator, port, routers) {
       }
     });
   });
-  return swaggerDocument(port, tags, paths);
+  return generateOpenApiDocument(port, tags, paths);
 }
 
+// src/http/tracing/emitLoggerError.ts
+import { logs } from "@opentelemetry/api-logs";
+import {
+  SEMATTRS_HTTP_METHOD,
+  SEMATTRS_HTTP_ROUTE,
+  SEMATTRS_HTTP_STATUS_CODE,
+  SEMATTRS_HTTP_TARGET
+} from "@opentelemetry/semantic-conventions";
+
+// src/http/tracing/pinoLogger.ts
+import pino from "pino";
+function pinoLogger(level) {
+  return pino({
+    level: level || "info",
+    formatters: {
+      level(label) {
+        return { level: label };
+      }
+    },
+    timestamp: pino.stdTimeFunctions.isoTime,
+    transport: {
+      target: "pino-pretty",
+      options: { colorize: true }
+    }
+  });
+}
+
+// src/http/tracing/emitLoggerError.ts
+var logger = pinoLogger("error");
+var emitLoggerError = (req, res, errorString) => {
+  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,
+      [SEMATTRS_HTTP_TARGET]: req.path,
+      [SEMATTRS_HTTP_ROUTE]: req.originalPath,
+      [SEMATTRS_HTTP_METHOD]: req.method,
+      [SEMATTRS_HTTP_STATUS_CODE]: res.statusCode
+    }
+  });
+  logger.error(errorString);
+};
+
+// src/http/tracing/openTelemetryCollector.ts
+import { HyperExpressInstrumentation } from "@forklaunch/opentelemetry-instrumentation-hyper-express";
+import {
+  metrics,
+  trace as trace2
+} from "@opentelemetry/api";
+import { logs as logs2 } from "@opentelemetry/api-logs";
+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 { Resource } 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
+} from "@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] = 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 (Traces + Logs + Metrics) started");
+  }
+  logger;
+  metrics;
+  log(level, msg, meta = {}) {
+    const activeSpan = trace2.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);
+    logs2.getLogger(this.serviceName).emit({
+      severityText: level,
+      body: msg,
+      attributes: meta
+    });
+  }
+  getMetric(metricId) {
+    return this.metrics[metricId];
+  }
+};
+new NodeSDK({
+  resource: new Resource({
+    [ATTR_SERVICE_NAME]: process.env.SERVICE_NAME
+  }),
+  traceExporter: new OTLPTraceExporter({
+    url: `${process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://localhost:4318"}/v1/traces`
+  }),
+  metricReader: new PeriodicExportingMetricReader({
+    exporter: new OTLPMetricExporter({
+      url: `${process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://localhost:4318"}/v1/metrics`
+    }),
+    exportIntervalMillis: 5e3
+  }),
+  logRecordProcessors: [
+    new BatchLogRecordProcessor(
+      new OTLPLogExporter({
+        url: `${process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://localhost:4318"}/v1/logs`
+      })
+    )
+  ],
+  instrumentations: [
+    new HttpInstrumentation(),
+    new ExpressInstrumentation({
+      requestHook: (span, info) => {
+        span.setAttribute(
+          "service.name",
+          process.env.SERVICE_NAME ?? "unknown"
+        );
+        span.setAttribute("api.name", info.request.contractDetails?.name);
+      }
+    }),
+    new HyperExpressInstrumentation()
+  ]
+}).start();
+var httpRequestsTotalCounter = metrics.getMeter(process.env.SERVICE_NAME || "unknown").createCounter("http_requests_total", {
+  description: "Number of HTTP requests"
+});
+
 // src/http/middleware/response/parse.middleware.ts
 import {
   prettyPrintParseErrors as prettyPrintParseErrors2
 } from "@forklaunch/validator";
 function parse2(req, res, next) {
-  console.debug("[MIDDLEWARE] parseResponse started");
   const { headers, responses } = res.responseSchemas;
   const parsedResponse = req.schemaValidator.parse(
     responses?.[res.statusCode],
@@ -2087,6 +2256,7 @@ function enrichExpressLikeSend(instance, req, res, originalSend, data, shouldEnr
   if (shouldEnrich) {
     if (res.statusCode === 404) {
       res.status(404);
+      emitLoggerError(req, res, "Not Found");
       originalSend.call(instance, "Not Found");
     }
     parse2(req, res, (err) => {
@@ -2097,6 +2267,7 @@ function enrichExpressLikeSend(instance, req, res, originalSend, data, shouldEnr
 ------------------
 ${res.locals.errorMessage}`;
         }
+        emitLoggerError(req, res, errorString);
         res.status(500);
         originalSend.call(instance, errorString);
         parseErrorSent = true;
@@ -2107,16 +2278,35 @@ ${res.locals.errorMessage}`;
     originalSend.call(instance, data);
   }
 }
+
+// src/http/utils/recordMetric.ts
+import {
+  SEMATTRS_HTTP_METHOD as SEMATTRS_HTTP_METHOD3,
+  SEMATTRS_HTTP_ROUTE as SEMATTRS_HTTP_ROUTE3,
+  SEMATTRS_HTTP_STATUS_CODE as SEMATTRS_HTTP_STATUS_CODE3
+} from "@opentelemetry/semantic-conventions";
+function recordMetric(req, res) {
+  httpRequestsTotalCounter.add(1, {
+    "service.name": process.env.SERVICE_NAME ?? "unknown",
+    "api.name": req.contractDetails?.name,
+    [SEMATTRS_HTTP_METHOD3]: req.method,
+    [SEMATTRS_HTTP_ROUTE3]: req.originalPath,
+    [SEMATTRS_HTTP_STATUS_CODE3]: res.statusCode || 0
+  });
+}
 export {
   ForklaunchExpressLikeApplication,
   ForklaunchExpressLikeRouter,
   HTTPStatuses,
+  OpenTelemetryCollector,
   delete_,
+  emitLoggerError,
   enrichExpressLikeSend,
   generateSwaggerDocument,
   get,
   getCodeForStatus,
   head,
+  httpRequestsTotalCounter,
   isClientError,
   isForklaunchRouter,
   isInformational,
@@ -2129,6 +2319,7 @@ export {
   patch,
   post,
   put,
+  recordMetric,
   trace,
   typedHandler
 };