@oneuptime/common 11.5.4 → 11.5.6

package/Server/Utils/LLM/LLMService.ts

@@ -43,6 +43,18 @@ export interface LLMCompletionRequest {
   maxTokens?: number | undefined;
   additionalParams?: JSONObject | undefined;
   tools?: Array<LLMToolDefinition> | undefined;
+  /** Per-attempt HTTP timeout. Callers may lower the provider default. */
+  requestTimeoutInMs?: number | undefined;
+  /** Number of retries after the initial request. */
+  requestRetries?: number | undefined;
+  /** Re-apply caller-owned request fields after provider-level overrides. */
+  protectRequestParameters?: boolean | undefined;
+  /**
+   * When false, provider HTTP error bodies are neither logged nor included in
+   * the exception captured by telemetry. Use this for requests whose provider
+   * may echo private prompt content in an error response.
+   */
+  includeProviderErrorDetails?: boolean | undefined;
   llmProviderConfig: LLMProviderConfig;
 }
 
@@ -74,6 +86,36 @@ export interface LLMProviderConfig {
 }
 
 export default class LLMService {
+  /*
+   * Provider-level parameters allowed on protected, unattended completions.
+   * This is deliberately a generation-only allowlist: capability fields such
+   * as tools, web_search_options, data_sources, modalities, audio, or future
+   * agent extensions must fail closed instead of silently widening egress or
+   * output behavior.
+   */
+  private static readonly PROTECTED_ADDITIONAL_PARAMETER_ALLOWLIST: Set<string> =
+    new Set([
+      "frequency_penalty",
+      "length_penalty",
+      "logit_bias",
+      "logprobs",
+      "max_completion_tokens",
+      "min_p",
+      "min_tokens",
+      "presence_penalty",
+      "random_seed",
+      "reasoning_effort",
+      "repetition_penalty",
+      "response_format",
+      "safe_prompt",
+      "seed",
+      "stop",
+      "top_k",
+      "top_logprobs",
+      "top_p",
+      "verbosity",
+    ]);
+
   @CaptureSpan()
   public static async getCompletion(
     request: LLMCompletionRequest,
@@ -152,6 +194,20 @@ export default class LLMService {
     });
   }
 
+  private static getProtectedAdditionalParameters(
+    additionalParams: JSONObject,
+  ): JSONObject {
+    const protectedParams: JSONObject = {};
+
+    for (const key of Object.keys(additionalParams)) {
+      if (this.PROTECTED_ADDITIONAL_PARAMETER_ALLOWLIST.has(key)) {
+        protectedParams[key] = additionalParams[key]!;
+      }
+    }
+
+    return protectedParams;
+  }
+
   private static parseOpenAIToolCalls(
     message: JSONObject,
   ): Array<LLMToolCall> | undefined {
@@ -227,9 +283,52 @@ export default class LLMService {
       data["tools"] = this.toOpenAITools(request.tools);
     }
 
-    // Provider-configured overrides are applied last so they win over defaults.
+    /*
+     * Provider-configured tuning overrides defaults unless the caller protects
+     * its request. Protected callers retain only generation-safe tuning fields
+     * so provider-native tools and future capability fields fail closed.
+     */
     if (request.additionalParams) {
-      Object.assign(data, request.additionalParams);
+      Object.assign(
+        data,
+        request.protectRequestParameters
+          ? this.getProtectedAdditionalParameters(request.additionalParams)
+          : request.additionalParams,
+      );
+    }
+
+    if (request.protectRequestParameters) {
+      const usesMaxCompletionTokens: boolean =
+        data["max_completion_tokens"] !== undefined;
+
+      data["model"] = modelName;
+      data["messages"] = this.toOpenAIMessages(request.messages);
+      data["temperature"] = request.temperature ?? 0.7;
+      data["stream"] = false;
+      data["n"] = 1;
+
+      if (request.maxTokens) {
+        if (usesMaxCompletionTokens) {
+          data["max_completion_tokens"] = request.maxTokens;
+          delete data["max_tokens"];
+        } else {
+          data["max_tokens"] = request.maxTokens;
+          delete data["max_completion_tokens"];
+        }
+      }
+
+      if (request.tools && request.tools.length > 0) {
+        data["tools"] = this.toOpenAITools(request.tools);
+      } else {
+        delete data["tools"];
+        delete data["tool_choice"];
+        delete data["functions"];
+        delete data["function_call"];
+        delete data["parallel_tool_calls"];
+      }
+
+      // Legacy compatible APIs may accept this fan-out control separately.
+      delete data["best_of"];
     }
 
     /*
@@ -291,6 +390,33 @@ export default class LLMService {
     };
   }
 
+  /**
+   * Handle provider HTTP failures before the decorated provider method
+   * rejects. Sanitizing here is important: @CaptureSpan records the exception,
+   * so redacting it only in AIService would be too late for logs and traces.
+   */
+  private static throwProviderHTTPError(data: {
+    providerName: string;
+    response: HTTPErrorResponse;
+    logAttributes: LogAttributes;
+    includeProviderErrorDetails?: boolean | undefined;
+  }): never {
+    logger.error(`Error from ${data.providerName} API:`, data.logAttributes);
+
+    if (data.includeProviderErrorDetails !== false) {
+      logger.error(data.response, data.logAttributes);
+      throw new BadDataException(
+        `${data.providerName} API error: ${JSON.stringify(
+          data.response.jsonData,
+        )}`,
+      );
+    }
+
+    throw new BadDataException(
+      `${data.providerName} API request failed. Review the provider configuration and try again.`,
+    );
+  }
+
   /*
    * Build the chat completions URL for an OpenAI-compatible server from the
    * configured base URL. Users enter the base URL in a few different ways, and
@@ -436,9 +562,9 @@ export default class LLMService {
             : {}),
         },
         options: {
-          retries: 2,
+          retries: request.requestRetries ?? 2,
           exponentialBackoff: true,
-          timeout: 120000,
+          timeout: request.requestTimeoutInMs ?? 120000,
         },
       });
 
@@ -448,11 +574,12 @@ export default class LLMService {
     };
 
     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)}`,
-      );
+      this.throwProviderHTTPError({
+        providerName: config.llmType.toString(),
+        response,
+        logAttributes,
+        includeProviderErrorDetails: request.includeProviderErrorDetails,
+      });
     }
 
     return this.parseOpenAIResponse(
@@ -513,9 +640,9 @@ export default class LLMService {
           "Content-Type": "application/json",
         },
         options: {
-          retries: 2,
+          retries: request.requestRetries ?? 2,
           exponentialBackoff: true,
-          timeout: 120000,
+          timeout: request.requestTimeoutInMs ?? 120000,
         },
       });
 
@@ -525,11 +652,12 @@ export default class LLMService {
     };
 
     if (response instanceof HTTPErrorResponse) {
-      logger.error("Error from Azure OpenAI API:", logAttributes);
-      logger.error(response, logAttributes);
-      throw new BadDataException(
-        `Azure OpenAI API error: ${JSON.stringify(response.jsonData)}`,
-      );
+      this.throwProviderHTTPError({
+        providerName: "Azure OpenAI",
+        response,
+        logAttributes,
+        includeProviderErrorDetails: request.includeProviderErrorDetails,
+      });
     }
 
     return this.parseOpenAIResponse(
@@ -717,9 +845,9 @@ export default class LLMService {
           "Content-Type": "application/json",
         },
         options: {
-          retries: 2,
+          retries: request.requestRetries ?? 2,
           exponentialBackoff: true,
-          timeout: 120000,
+          timeout: request.requestTimeoutInMs ?? 120000,
         },
       });
 
@@ -729,11 +857,12 @@ export default class LLMService {
     };
 
     if (response instanceof HTTPErrorResponse) {
-      logger.error("Error from Anthropic API:", anthropicLogAttributes);
-      logger.error(response, anthropicLogAttributes);
-      throw new BadDataException(
-        `Anthropic API error: ${JSON.stringify(response.jsonData)}`,
-      );
+      this.throwProviderHTTPError({
+        providerName: "Anthropic",
+        response,
+        logAttributes: anthropicLogAttributes,
+        includeProviderErrorDetails: request.includeProviderErrorDetails,
+      });
     }
 
     const jsonData: JSONObject = response.jsonData as JSONObject;
@@ -855,9 +984,9 @@ export default class LLMService {
           "Content-Type": "application/json",
         },
         options: {
-          retries: 2,
+          retries: request.requestRetries ?? 2,
           exponentialBackoff: true,
-          timeout: 300000, // 5 minutes for Ollama as it may be slower
+          timeout: request.requestTimeoutInMs ?? 300000, // Ollama may be slower
         },
       });
 
@@ -867,11 +996,12 @@ export default class LLMService {
     };
 
     if (response instanceof HTTPErrorResponse) {
-      logger.error("Error from Ollama API:", ollamaLogAttributes);
-      logger.error(response, ollamaLogAttributes);
-      throw new BadDataException(
-        `Ollama API error: ${JSON.stringify(response.jsonData)}`,
-      );
+      this.throwProviderHTTPError({
+        providerName: "Ollama",
+        response,
+        logAttributes: ollamaLogAttributes,
+        includeProviderErrorDetails: request.includeProviderErrorDetails,
+      });
     }
 
     const jsonData: JSONObject = response.jsonData as JSONObject;

package/Server/Utils/Monitor/Criteria/SqlMonitorCriteria.ts

@@ -0,0 +1,152 @@
+import DataToProcess from "../DataToProcess";
+import CompareCriteria from "./CompareCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+} from "../../../../Types/Monitor/CriteriaFilter";
+import SqlMonitorResponse from "../../../../Types/Monitor/SqlMonitor/SqlMonitorResponse";
+import ProbeMonitorResponse from "../../../../Types/Probe/ProbeMonitorResponse";
+import CaptureSpan from "../../Telemetry/CaptureSpan";
+
+export default class SqlMonitorCriteria {
+  @CaptureSpan()
+  public static async isMonitorInstanceCriteriaFilterMet(input: {
+    dataToProcess: DataToProcess;
+    criteriaFilter: CriteriaFilter;
+  }): Promise<string | null> {
+    let threshold: number | string | undefined | null =
+      input.criteriaFilter.value;
+
+    const dataToProcess: ProbeMonitorResponse =
+      input.dataToProcess as ProbeMonitorResponse;
+
+    const sqlResponse: SqlMonitorResponse | undefined =
+      dataToProcess.sqlQueryMonitorResponse;
+
+    // Is the database reachable / did the check succeed?
+    if (input.criteriaFilter.checkOn === CheckOn.SqlIsOnline) {
+      return CompareCriteria.compareCriteriaBoolean({
+        value: dataToProcess.isOnline as boolean,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    // Number of rows the query returned.
+    if (input.criteriaFilter.checkOn === CheckOn.SqlQueryRowCount) {
+      threshold = CompareCriteria.convertToNumber(threshold);
+
+      if (threshold === null || threshold === undefined) {
+        return null;
+      }
+
+      if (
+        sqlResponse?.rowCount === null ||
+        sqlResponse?.rowCount === undefined
+      ) {
+        return null;
+      }
+
+      return CompareCriteria.compareCriteriaNumbers({
+        value: sqlResponse.rowCount,
+        threshold: threshold as number,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    // Query execution time (in ms).
+    if (input.criteriaFilter.checkOn === CheckOn.SqlQueryExecutionTime) {
+      threshold = CompareCriteria.convertToNumber(threshold);
+
+      if (threshold === null || threshold === undefined) {
+        return null;
+      }
+
+      const executionTime: number | undefined =
+        sqlResponse?.responseTimeInMs ?? dataToProcess.responseTimeInMs;
+
+      if (executionTime === null || executionTime === undefined) {
+        return null;
+      }
+
+      return CompareCriteria.compareCriteriaNumbers({
+        value: executionTime,
+        threshold: threshold as number,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    /*
+     * The first column of the first row — the natural target for a
+     * COUNT(*)-style query. Compared numerically when both sides look
+     * numeric, otherwise as strings.
+     */
+    if (input.criteriaFilter.checkOn === CheckOn.SqlQueryScalarValue) {
+      const scalarValue: string | number | boolean | null | undefined =
+        sqlResponse?.scalarValue;
+
+      if (scalarValue === null || scalarValue === undefined) {
+        return null;
+      }
+
+      const numericThreshold: number | null =
+        CompareCriteria.convertToNumber(threshold);
+      const scalarAsNumber: number = Number(scalarValue);
+
+      if (
+        numericThreshold !== null &&
+        typeof scalarValue !== "boolean" &&
+        !isNaN(scalarAsNumber)
+      ) {
+        const numericResult: string | null =
+          CompareCriteria.compareCriteriaNumbers({
+            value: scalarAsNumber,
+            threshold: numericThreshold,
+            criteriaFilter: input.criteriaFilter,
+          });
+
+        if (numericResult) {
+          return numericResult;
+        }
+      }
+
+      if (threshold !== null && threshold !== undefined) {
+        return CompareCriteria.compareCriteriaStrings({
+          value: String(scalarValue),
+          threshold: String(threshold),
+          criteriaFilter: input.criteriaFilter,
+        });
+      }
+
+      return null;
+    }
+
+    // The query error message (present when the query failed).
+    if (input.criteriaFilter.checkOn === CheckOn.SqlQueryError) {
+      const emptyNotEmptyResult: string | null =
+        CompareCriteria.compareEmptyAndNotEmpty({
+          value: sqlResponse?.queryError,
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (emptyNotEmptyResult) {
+        return emptyNotEmptyResult;
+      }
+
+      if (
+        threshold !== null &&
+        threshold !== undefined &&
+        typeof sqlResponse?.queryError === "string"
+      ) {
+        return CompareCriteria.compareCriteriaStrings({
+          value: sqlResponse.queryError,
+          threshold: threshold.toString(),
+          criteriaFilter: input.criteriaFilter,
+        });
+      }
+
+      return null;
+    }
+
+    return null;
+  }
+}

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -20,6 +20,7 @@ import SnmpMonitorCriteria from "./Criteria/SnmpMonitorCriteria";
 import DnsMonitorCriteria from "./Criteria/DnsMonitorCriteria";
 import DomainMonitorCriteria from "./Criteria/DomainMonitorCriteria";
 import DnssecMonitorCriteria from "./Criteria/DnssecMonitorCriteria";
+import SqlMonitorCriteria from "./Criteria/SqlMonitorCriteria";
 import ExternalStatusPageMonitorCriteria from "./Criteria/ExternalStatusPageMonitorCriteria";
 import MonitorCriteriaMessageBuilder from "./MonitorCriteriaMessageBuilder";
 import MonitorCriteriaDataExtractor from "./MonitorCriteriaDataExtractor";
@@ -41,6 +42,7 @@ import ProbeApiIngestResponse, {
 import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
 import RequestFailedDetails from "../../../Types/Probe/RequestFailedDetails";
 import IncomingMonitorRequest from "../../../Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
+import SqlMonitorResponse from "../../../Types/Monitor/SqlMonitor/SqlMonitorResponse";
 import MonitorType from "../../../Types/Monitor/MonitorType";
 import { CheckOn, CriteriaFilter } from "../../../Types/Monitor/CriteriaFilter";
 import OneUptimeDate from "../../../Types/Date";
@@ -578,6 +580,21 @@ ${contextBlock}
         };
       }
 
+      if (input.monitor.monitorType === MonitorType.SQLQuery) {
+        const sqlResponse: SqlMonitorResponse | undefined = (
+          input.dataToProcess as ProbeMonitorResponse
+        ).sqlQueryMonitorResponse;
+
+        storageMap = {
+          rowCount: sqlResponse?.rowCount,
+          scalarValue: sqlResponse?.scalarValue,
+          firstRow: sqlResponse?.firstRow,
+          executionTimeInMs: sqlResponse?.responseTimeInMs,
+          queryError: sqlResponse?.queryError,
+          isOnline: (input.dataToProcess as ProbeMonitorResponse).isOnline,
+        };
+      }
+
       let expression: string = input.criteriaFilter.value as string;
       expression = VMUtil.replaceValueInPlace(storageMap, expression, false);
 
@@ -823,6 +840,18 @@ ${contextBlock}
       }
     }
 
+    if (input.monitor.monitorType === MonitorType.SQLQuery) {
+      const sqlMonitorResult: string | null =
+        await SqlMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (sqlMonitorResult) {
+        return sqlMonitorResult;
+      }
+    }
+
     if (input.monitor.monitorType === MonitorType.ExternalStatusPage) {
       const externalStatusPageResult: string | null =
         await ExternalStatusPageMonitorCriteria.isMonitorInstanceCriteriaFilterMet(

package/Server/Utils/Monitor/MonitorCriteriaExpectationBuilder.ts

@@ -22,6 +22,7 @@ export default class MonitorCriteriaExpectationBuilder {
 
   public static describeCriteriaExpectation(
     criteriaFilter: CriteriaFilter,
+    options?: { unit?: string | undefined },
   ): string | null {
     if (!criteriaFilter.filterType) {
       return null;
@@ -31,24 +32,33 @@ export default class MonitorCriteriaExpectationBuilder {
 
     const value: string | number | undefined = criteriaFilter.value;
 
+    /*
+     * Suffix numeric-threshold comparisons with the metric's display unit
+     * (e.g. "greater than 5 sec") so the threshold reads in the same unit
+     * as the observed value. Only the value-comparison filter types below
+     * carry a numeric threshold — the others (empty, boolean, heartbeat
+     * windows, …) supply their own wording and get no suffix.
+     */
+    const unitSuffix: string = options?.unit ? ` ${options.unit}` : "";
+
     switch (criteriaFilter.filterType) {
       case FilterType.GreaterThan:
-        expectation = `to be greater than ${value}`;
+        expectation = `to be greater than ${value}${unitSuffix}`;
         break;
       case FilterType.GreaterThanOrEqualTo:
-        expectation = `to be greater than or equal to ${value}`;
+        expectation = `to be greater than or equal to ${value}${unitSuffix}`;
         break;
       case FilterType.LessThan:
-        expectation = `to be less than ${value}`;
+        expectation = `to be less than ${value}${unitSuffix}`;
         break;
       case FilterType.LessThanOrEqualTo:
-        expectation = `to be less than or equal to ${value}`;
+        expectation = `to be less than or equal to ${value}${unitSuffix}`;
         break;
       case FilterType.EqualTo:
-        expectation = `to equal ${value}`;
+        expectation = `to equal ${value}${unitSuffix}`;
         break;
       case FilterType.NotEqualTo:
-        expectation = `to not equal ${value}`;
+        expectation = `to not equal ${value}${unitSuffix}`;
         break;
       case FilterType.Contains:
         expectation = `to contain ${value}`;

package/Server/Utils/Monitor/MonitorCriteriaMessageBuilder.ts

@@ -53,9 +53,23 @@ export default class MonitorCriteriaMessageBuilder {
     dataToProcess: DataToProcess;
     monitorStep: MonitorStep;
   }): string | null {
+    /*
+     * Resolve the metric's display unit (undefined for non-metric criteria)
+     * so the threshold in the expectation clause reads in the same unit as
+     * the observed value — "recorded latest 0.06 sec (expected to be greater
+     * than 5 sec)" rather than the unitless "0.06 (expected ... 5)".
+     */
+    const metricDisplayUnit: string | undefined =
+      MonitorCriteriaObservationBuilder.getMetricValueDisplayUnit({
+        criteriaFilter: input.criteriaFilter,
+        dataToProcess: input.dataToProcess,
+        monitorStep: input.monitorStep,
+      });
+
     const expectation: string | null =
       MonitorCriteriaExpectationBuilder.describeCriteriaExpectation(
         input.criteriaFilter,
+        { unit: metricDisplayUnit },
       );
 
     const observation: string | null =

package/Server/Utils/Monitor/MonitorCriteriaMessageFormatter.ts

@@ -136,7 +136,10 @@ export default class MonitorCriteriaMessageFormatter {
     return null;
   }
 
-  public static summarizeNumericSeries(values: Array<number>): string | null {
+  public static summarizeNumericSeries(
+    values: Array<number>,
+    unit?: string | undefined,
+  ): string | null {
     if (!values.length) {
       return null;
     }
@@ -147,12 +150,18 @@ export default class MonitorCriteriaMessageFormatter {
       return null;
     }
 
+    /*
+     * Suffix each value with its unit (e.g. "0.06 sec") so the reader knows
+     * what the numbers mean. Empty when the metric has no known unit.
+     */
+    const unitSuffix: string = unit ? ` ${unit}` : "";
+
     const latestFormatted: string | null =
       MonitorCriteriaMessageFormatter.formatNumber(latest, {
         maximumFractionDigits: 2,
       });
 
-    let summary: string = `latest ${latestFormatted ?? latest}`;
+    let summary: string = `latest ${latestFormatted ?? latest}${unitSuffix}`;
 
     if (values.length > 1) {
       const min: number = Math.min(...values);
@@ -167,7 +176,9 @@ export default class MonitorCriteriaMessageFormatter {
           maximumFractionDigits: 2,
         });
 
-      summary += ` (min ${minFormatted ?? min}, max ${maxFormatted ?? max})`;
+      summary += ` (min ${minFormatted ?? min}${unitSuffix}, max ${
+        maxFormatted ?? max
+      }${unitSuffix})`;
     }
 
     summary += ` across ${values.length} data point${