@oneuptime/common 10.0.83 → 10.0.85

package/Server/Utils/LLM/LLMService.ts

@@ -46,7 +46,11 @@ export default class LLMService {
 
     switch (config.llmType) {
       case LlmType.OpenAI:
-        return await this.getOpenAICompletion(config, request);
+      case LlmType.Groq:
+      case LlmType.Mistral:
+        return await this.getOpenAICompatibleCompletion(config, request);
+      case LlmType.AzureOpenAI:
+        return await this.getAzureOpenAICompletion(config, request);
       case LlmType.Anthropic:
         return await this.getAnthropicCompletion(config, request);
       case LlmType.Ollama:
@@ -57,17 +61,32 @@ export default class LLMService {
   }
 
   @CaptureSpan()
-  private static async getOpenAICompletion(
+  private static async getOpenAICompatibleCompletion(
     config: LLMProviderConfig,
     request: LLMCompletionRequest,
   ): Promise<LLMCompletionResponse> {
     if (!config.apiKey) {
-      throw new BadDataException("OpenAI API key is required");
+      throw new BadDataException(`${config.llmType} API key is required`);
     }
 
-    const baseUrl: string = config.baseUrl || "https://api.openai.com/v1";
-    const modelName: string = config.modelName || "gpt-4o";
+    const defaultBaseUrls: Record<string, string> = {
+      [LlmType.OpenAI]: "https://api.openai.com/v1",
+      [LlmType.Groq]: "https://api.groq.com/openai/v1",
+      [LlmType.Mistral]: "https://api.mistral.ai/v1",
+    };
 
+    const defaultModels: Record<string, string> = {
+      [LlmType.OpenAI]: "gpt-4o",
+      [LlmType.Groq]: "llama-3.3-70b-versatile",
+      [LlmType.Mistral]: "mistral-large-latest",
+    };
+
+    const baseUrl: string =
+      config.baseUrl ||
+      defaultBaseUrls[config.llmType] ||
+      "https://api.openai.com/v1";
+    const modelName: string =
+      config.modelName || defaultModels[config.llmType] || "gpt-4o";
     const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
       await API.post<JSONObject>({
         url: URL.fromString(`${baseUrl}/chat/completions`),
@@ -88,20 +107,122 @@ export default class LLMService {
         options: {
           retries: 2,
           exponentialBackoff: true,
-          timeout: 120000, // 2 minutes timeout for LLM calls
+          timeout: 120000,
+        },
+      });
+
+    const logAttributes: LogAttributes = {
+      llmType: config.llmType,
+      modelName: modelName,
+    };
+
+    if (response instanceof HTTPErrorResponse) {
+      logger.error(`Error from ${config.llmType} API:`, logAttributes);
+      logger.error(response, logAttributes);
+      throw new BadDataException(
+        `${config.llmType} API error: ${JSON.stringify(response.jsonData)}`,
+      );
+    }
+
+    const jsonData: JSONObject = response.jsonData as JSONObject;
+    const choices: Array<JSONObject> = jsonData["choices"] as Array<JSONObject>;
+
+    if (!choices || choices.length === 0) {
+      throw new BadDataException(`No response from ${config.llmType}`);
+    }
+
+    const message: JSONObject = choices[0]!["message"] as JSONObject;
+    const usage: JSONObject = jsonData["usage"] as JSONObject;
+
+    return {
+      content: message["content"] as string,
+      usage: usage
+        ? {
+            promptTokens: usage["prompt_tokens"] as number,
+            completionTokens: usage["completion_tokens"] as number,
+            totalTokens: usage["total_tokens"] as number,
+          }
+        : undefined,
+    };
+  }
+
+  /*
+   * Default Azure OpenAI API version. Users can override by including
+   * ?api-version=... in their configured base URL.
+   */
+  private static readonly AZURE_OPENAI_DEFAULT_API_VERSION: string =
+    "2024-10-21";
+
+  private static buildAzureOpenAIChatCompletionsUrl(baseUrl: string): string {
+    const trimmed: string = baseUrl.replace(/\/+$/, "");
+    const queryIndex: number = trimmed.indexOf("?");
+    const pathPart: string =
+      queryIndex >= 0 ? trimmed.substring(0, queryIndex) : trimmed;
+    const queryPart: string =
+      queryIndex >= 0 ? trimmed.substring(queryIndex + 1) : "";
+
+    const params: URLSearchParams = new URLSearchParams(queryPart);
+    if (!params.has("api-version")) {
+      params.set("api-version", LLMService.AZURE_OPENAI_DEFAULT_API_VERSION);
+    }
+
+    return `${pathPart}/chat/completions?${params.toString()}`;
+  }
+
+  @CaptureSpan()
+  private static async getAzureOpenAICompletion(
+    config: LLMProviderConfig,
+    request: LLMCompletionRequest,
+  ): Promise<LLMCompletionResponse> {
+    if (!config.apiKey) {
+      throw new BadDataException("Azure OpenAI API key is required");
+    }
+
+    if (!config.baseUrl) {
+      throw new BadDataException(
+        "Azure OpenAI Base URL is required (e.g. https://<resource>.openai.azure.com/openai/deployments/<deployment>)",
+      );
+    }
+
+    const modelName: string = config.modelName || "gpt-4o";
+    const requestUrl: string = LLMService.buildAzureOpenAIChatCompletionsUrl(
+      config.baseUrl,
+    );
+
+    const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
+      await API.post<JSONObject>({
+        url: URL.fromString(requestUrl),
+        data: {
+          model: modelName,
+          messages: request.messages.map((msg: LLMMessage) => {
+            return {
+              role: msg.role,
+              content: msg.content,
+            };
+          }),
+          temperature: request.temperature ?? 0.7,
+        },
+        headers: {
+          "api-key": config.apiKey,
+          "Content-Type": "application/json",
+        },
+        options: {
+          retries: 2,
+          exponentialBackoff: true,
+          timeout: 120000,
         },
       });
 
-    const openAILogAttributes: LogAttributes = {
+    const logAttributes: LogAttributes = {
       llmType: config.llmType,
       modelName: modelName,
     };
 
     if (response instanceof HTTPErrorResponse) {
-      logger.error("Error from OpenAI API:", openAILogAttributes);
-      logger.error(response, openAILogAttributes);
+      logger.error("Error from Azure OpenAI API:", logAttributes);
+      logger.error(response, logAttributes);
       throw new BadDataException(
-        `OpenAI API error: ${JSON.stringify(response.jsonData)}`,
+        `Azure OpenAI API error: ${JSON.stringify(response.jsonData)}`,
       );
     }
 
@@ -109,7 +230,7 @@ export default class LLMService {
     const choices: Array<JSONObject> = jsonData["choices"] as Array<JSONObject>;
 
     if (!choices || choices.length === 0) {
-      throw new BadDataException("No response from OpenAI");
+      throw new BadDataException("No response from Azure OpenAI");
     }
 
     const message: JSONObject = choices[0]!["message"] as JSONObject;

package/Server/Utils/Monitor/MonitorAlert.ts

@@ -37,7 +37,7 @@ export default class MonitorAlert {
     evaluationSummary?: MonitorEvaluationSummary | undefined;
     breachingSeriesFingerprints?: Set<string> | undefined;
   }): Promise<Array<Alert>> {
-    // check active alerts and if there are open alerts, do not cretae anothr alert.
+    // check active alerts and if there are open alerts, do not create another alert.
     const openAlerts: Array<Alert> = await AlertService.findBy({
       query: {
         monitor: input.monitorId!,

package/Server/Utils/Monitor/MonitorIncident.ts

@@ -50,7 +50,7 @@ export default class MonitorIncident {
      */
     breachingSeriesFingerprints?: Set<string> | undefined;
   }): Promise<Array<Incident>> {
-    // check active incidents and if there are open incidents, do not cretae anothr incident.
+    // check active incidents and if there are open incidents, do not create another incident.
     const openIncidents: Array<Incident> = await IncidentService.findBy({
       query: {
         monitors: [input.monitorId],

package/Server/Utils/StartServer.ts

@@ -7,6 +7,7 @@ import {
   getFrontendEnvVars,
 } from "../EnvironmentConfig";
 import LocalCache from "../Infrastructure/LocalCache";
+import HttpMetricsMiddleware from "../Middleware/HttpMetricsMiddleware";
 import "./Environment";
 import Express, {
   ExpressApplication,
@@ -106,6 +107,7 @@ const setDefaultHeaders: RequestHandler = (
 };
 
 app.use(cors());
+app.use(HttpMetricsMiddleware);
 app.use(setDefaultHeaders);
 
 // Set the view engine to ejs

package/Server/Utils/Telemetry/AppMetrics.ts

@@ -0,0 +1,211 @@
+import Telemetry, {
+  TelemetryCounter,
+  TelemetryHistogram,
+  TelemetryUpDownCounter,
+} from "../Telemetry";
+
+/**
+ * Central catalog of metric instruments emitted by OneUptime services about
+ * themselves (server-side observability of the OneUptime platform). All
+ * instruments are lazy-created on first access and cached, so importing this
+ * module from multiple call sites is safe.
+ *
+ * Naming follows OpenTelemetry semantic conventions where applicable, with a
+ * `oneuptime.` prefix for application-specific signals.
+ *
+ * Cardinality rule: never attach high-cardinality identifiers (userId,
+ * projectId, monitorId, requestId, raw URLs) to metric attributes — those
+ * belong on traces and logs. Stick to bounded enums (method, status_code,
+ * monitor type, queue name, channel, outcome).
+ */
+export default class AppMetrics {
+  // -- HTTP server -------------------------------------------------------
+
+  private static httpRequestCounter: TelemetryCounter | null = null;
+  private static httpRequestDuration: TelemetryHistogram | null = null;
+  private static httpRequestsInFlight: TelemetryUpDownCounter | null = null;
+
+  public static getHttpRequestCounter(): TelemetryCounter {
+    if (!this.httpRequestCounter) {
+      this.httpRequestCounter = Telemetry.getCounter({
+        name: "http.server.request.count",
+        description:
+          "Number of HTTP requests handled by the server, partitioned by method, route and status class.",
+        unit: "1",
+      });
+    }
+
+    return this.httpRequestCounter;
+  }
+
+  public static getHttpRequestDuration(): TelemetryHistogram {
+    if (!this.httpRequestDuration) {
+      this.httpRequestDuration = Telemetry.getHistogram({
+        name: "http.server.request.duration",
+        description: "Duration of HTTP server requests.",
+        unit: "ms",
+      });
+    }
+
+    return this.httpRequestDuration;
+  }
+
+  public static getHttpRequestsInFlight(): TelemetryUpDownCounter {
+    if (!this.httpRequestsInFlight) {
+      this.httpRequestsInFlight = Telemetry.getGauge({
+        name: "http.server.active_requests",
+        description: "Number of HTTP requests currently being processed.",
+        unit: "1",
+      });
+    }
+
+    return this.httpRequestsInFlight;
+  }
+
+  // -- Worker / background jobs -----------------------------------------
+
+  private static workerJobCounter: TelemetryCounter | null = null;
+  private static workerJobDuration: TelemetryHistogram | null = null;
+  private static workerJobsInFlight: TelemetryUpDownCounter | null = null;
+
+  public static getWorkerJobCounter(): TelemetryCounter {
+    if (!this.workerJobCounter) {
+      this.workerJobCounter = Telemetry.getCounter({
+        name: "worker.job.count",
+        description:
+          "Number of background worker jobs processed, partitioned by queue, job name and outcome.",
+        unit: "1",
+      });
+    }
+
+    return this.workerJobCounter;
+  }
+
+  public static getWorkerJobDuration(): TelemetryHistogram {
+    if (!this.workerJobDuration) {
+      this.workerJobDuration = Telemetry.getHistogram({
+        name: "worker.job.duration",
+        description: "Duration of background worker job execution.",
+        unit: "ms",
+      });
+    }
+
+    return this.workerJobDuration;
+  }
+
+  public static getWorkerJobsInFlight(): TelemetryUpDownCounter {
+    if (!this.workerJobsInFlight) {
+      this.workerJobsInFlight = Telemetry.getGauge({
+        name: "worker.job.active",
+        description: "Number of worker jobs currently executing.",
+        unit: "1",
+      });
+    }
+
+    return this.workerJobsInFlight;
+  }
+
+  // -- Probe monitor checks ---------------------------------------------
+
+  private static probeCheckCounter: TelemetryCounter | null = null;
+  private static probeCheckDuration: TelemetryHistogram | null = null;
+
+  public static getProbeCheckCounter(): TelemetryCounter {
+    if (!this.probeCheckCounter) {
+      this.probeCheckCounter = Telemetry.getCounter({
+        name: "probe.monitor.check.count",
+        description:
+          "Number of monitor checks executed by the probe, partitioned by monitor type and outcome.",
+        unit: "1",
+      });
+    }
+
+    return this.probeCheckCounter;
+  }
+
+  public static getProbeCheckDuration(): TelemetryHistogram {
+    if (!this.probeCheckDuration) {
+      this.probeCheckDuration = Telemetry.getHistogram({
+        name: "probe.monitor.check.duration",
+        description: "Duration of probe monitor checks.",
+        unit: "ms",
+      });
+    }
+
+    return this.probeCheckDuration;
+  }
+
+  // -- Notification dispatch (Mail/SMS/Call/Push) -----------------------
+
+  private static notificationCounter: TelemetryCounter | null = null;
+  private static notificationDuration: TelemetryHistogram | null = null;
+
+  public static getNotificationCounter(): TelemetryCounter {
+    if (!this.notificationCounter) {
+      this.notificationCounter = Telemetry.getCounter({
+        name: "notification.send.count",
+        description:
+          "Number of notifications dispatched, partitioned by channel and outcome.",
+        unit: "1",
+      });
+    }
+
+    return this.notificationCounter;
+  }
+
+  public static getNotificationDuration(): TelemetryHistogram {
+    if (!this.notificationDuration) {
+      this.notificationDuration = Telemetry.getHistogram({
+        name: "notification.send.duration",
+        description: "Duration of notification dispatch calls.",
+        unit: "ms",
+      });
+    }
+
+    return this.notificationDuration;
+  }
+
+  // -- OTLP / telemetry ingestion ---------------------------------------
+
+  private static ingestCounter: TelemetryCounter | null = null;
+  private static ingestDuration: TelemetryHistogram | null = null;
+  private static ingestPayloadBytes: TelemetryHistogram | null = null;
+
+  public static getIngestCounter(): TelemetryCounter {
+    if (!this.ingestCounter) {
+      this.ingestCounter = Telemetry.getCounter({
+        name: "telemetry.ingest.request.count",
+        description:
+          "Number of telemetry ingestion requests received, partitioned by signal and outcome.",
+        unit: "1",
+      });
+    }
+
+    return this.ingestCounter;
+  }
+
+  public static getIngestDuration(): TelemetryHistogram {
+    if (!this.ingestDuration) {
+      this.ingestDuration = Telemetry.getHistogram({
+        name: "telemetry.ingest.request.duration",
+        description: "Duration of telemetry ingestion request handling.",
+        unit: "ms",
+      });
+    }
+
+    return this.ingestDuration;
+  }
+
+  public static getIngestPayloadBytes(): TelemetryHistogram {
+    if (!this.ingestPayloadBytes) {
+      this.ingestPayloadBytes = Telemetry.getHistogram({
+        name: "telemetry.ingest.request.payload.size",
+        description:
+          "Size of telemetry ingestion request payloads, after decompression.",
+        unit: "By",
+      });
+    }
+
+    return this.ingestPayloadBytes;
+  }
+}

package/Server/Utils/Telemetry/RuntimeMetrics.ts

@@ -0,0 +1,169 @@
+import { monitorEventLoopDelay, IntervalHistogram } from "perf_hooks";
+import type { Attributes, ObservableResult } from "@opentelemetry/api";
+import Telemetry from "../Telemetry";
+import logger from "../Logger";
+
+/**
+ * Process-level runtime metrics (memory, CPU, event-loop lag).
+ *
+ * Implemented as observable gauges so they're sampled at export time rather
+ * than continuously. Registered once per process from `Telemetry.init()`.
+ *
+ * Metric names follow the OpenTelemetry semantic conventions for Node.js
+ * process and runtime metrics where they exist.
+ */
+export default class RuntimeMetrics {
+  private static initialized: boolean = false;
+
+  private static lastCpuUsage: NodeJS.CpuUsage | null = null;
+  private static lastCpuSampleTimestampNs: bigint | null = null;
+
+  private static eventLoopHistogram: IntervalHistogram | null = null;
+
+  public static init(): void {
+    if (this.initialized) {
+      return;
+    }
+
+    if (!Telemetry.isMetricsEnabled()) {
+      return;
+    }
+
+    try {
+      this.startEventLoopMonitor();
+
+      Telemetry.getObservableGauge({
+        name: "process.runtime.nodejs.memory.heap.used",
+        description: "V8 heap memory currently in use.",
+        unit: "By",
+        callback: (result: ObservableResult<Attributes>) => {
+          result.observe(process.memoryUsage().heapUsed);
+        },
+      });
+
+      Telemetry.getObservableGauge({
+        name: "process.runtime.nodejs.memory.heap.total",
+        description: "Total size of allocated V8 heap.",
+        unit: "By",
+        callback: (result: ObservableResult<Attributes>) => {
+          result.observe(process.memoryUsage().heapTotal);
+        },
+      });
+
+      Telemetry.getObservableGauge({
+        name: "process.runtime.nodejs.memory.rss",
+        description:
+          "Resident set size — total memory allocated to the Node.js process.",
+        unit: "By",
+        callback: (result: ObservableResult<Attributes>) => {
+          result.observe(process.memoryUsage().rss);
+        },
+      });
+
+      Telemetry.getObservableGauge({
+        name: "process.runtime.nodejs.memory.external",
+        description:
+          "Memory used by C++ objects bound to JavaScript objects managed by V8.",
+        unit: "By",
+        callback: (result: ObservableResult<Attributes>) => {
+          result.observe(process.memoryUsage().external);
+        },
+      });
+
+      Telemetry.getObservableGauge({
+        name: "process.runtime.nodejs.cpu.utilization",
+        description:
+          "Fraction of a single CPU core used by this Node.js process since the last sample (0-1, may exceed 1 on multi-core).",
+        unit: "1",
+        callback: (result: ObservableResult<Attributes>) => {
+          const utilization: number = this.sampleCpuUtilization();
+          if (Number.isFinite(utilization)) {
+            result.observe(utilization);
+          }
+        },
+      });
+
+      Telemetry.getObservableGauge({
+        name: "process.runtime.nodejs.eventloop.lag",
+        description:
+          "Event loop scheduling delay (mean and p99 over the sampling interval).",
+        unit: "ms",
+        callback: (result: ObservableResult<Attributes>) => {
+          if (!this.eventLoopHistogram) {
+            return;
+          }
+
+          const meanMs: number = this.eventLoopHistogram.mean / 1e6;
+          const p99Ms: number = this.eventLoopHistogram.percentile(99) / 1e6;
+          const maxMs: number = this.eventLoopHistogram.max / 1e6;
+
+          if (Number.isFinite(meanMs)) {
+            result.observe(meanMs, { quantile: "mean" });
+          }
+          if (Number.isFinite(p99Ms)) {
+            result.observe(p99Ms, { quantile: "p99" });
+          }
+          if (Number.isFinite(maxMs)) {
+            result.observe(maxMs, { quantile: "max" });
+          }
+
+          this.eventLoopHistogram.reset();
+        },
+      });
+
+      Telemetry.getObservableGauge({
+        name: "process.runtime.nodejs.uptime",
+        description: "Time elapsed since the Node.js process started.",
+        unit: "s",
+        callback: (result: ObservableResult<Attributes>) => {
+          result.observe(process.uptime());
+        },
+      });
+
+      this.initialized = true;
+    } catch (err) {
+      logger.error("Failed to initialize Node.js runtime metrics");
+      logger.error(err);
+    }
+  }
+
+  private static startEventLoopMonitor(): void {
+    if (this.eventLoopHistogram) {
+      return;
+    }
+
+    /*
+     * Resolution in milliseconds (the API expects nanoseconds via internal
+     * resolution, but `monitorEventLoopDelay` accepts a millisecond value).
+     */
+    this.eventLoopHistogram = monitorEventLoopDelay({ resolution: 20 });
+    this.eventLoopHistogram.enable();
+  }
+
+  private static sampleCpuUtilization(): number {
+    const nowNs: bigint = process.hrtime.bigint();
+    const usage: NodeJS.CpuUsage = process.cpuUsage();
+
+    if (!this.lastCpuUsage || !this.lastCpuSampleTimestampNs) {
+      this.lastCpuUsage = usage;
+      this.lastCpuSampleTimestampNs = nowNs;
+      return 0;
+    }
+
+    const elapsedNs: bigint = nowNs - this.lastCpuSampleTimestampNs;
+    const elapsedMicros: number = Number(elapsedNs / BigInt(1000));
+
+    if (elapsedMicros <= 0) {
+      return 0;
+    }
+
+    const userDelta: number = usage.user - this.lastCpuUsage.user;
+    const systemDelta: number = usage.system - this.lastCpuUsage.system;
+    const utilization: number = (userDelta + systemDelta) / elapsedMicros;
+
+    this.lastCpuUsage = usage;
+    this.lastCpuSampleTimestampNs = nowNs;
+
+    return utilization;
+  }
+}