@oneuptime/common 11.5.12 → 11.6.0

package/Tests/Server/Utils/TelemetryImprovementTaskTrigger.test.ts

@@ -0,0 +1,141 @@
+import TelemetryImprovementTaskTrigger from "../../../Server/Utils/AI/SRE/TelemetryImprovementTaskTrigger";
+import SubjectCodeFixRun from "../../../Server/Utils/AI/SRE/SubjectCodeFixRun";
+import ServiceService from "../../../Server/Services/ServiceService";
+import Service from "../../../Models/DatabaseModels/Service";
+import AIRun from "../../../Models/DatabaseModels/AIRun";
+import CodeFixTaskType from "../../../Types/AI/CodeFixTaskType";
+import ObjectID from "../../../Types/ObjectID";
+import { describe, expect, test, afterEach, beforeEach } from "@jest/globals";
+
+/*
+ * The service-scoped instrumentation-improvement triggers (ImproveLogging /
+ * ImproveTracing): human-triggered, so every unmet gate fails EARLY with a
+ * clear message — unsupported recipe, missing/foreign service, no
+ * GitHub-App repository, or a duplicate active run for the same service.
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+const telemetryServiceId: ObjectID = ObjectID.generate();
+const userId: ObjectID = ObjectID.generate();
+
+function mockService(overrides: Partial<Service> = {}): void {
+  jest.spyOn(ServiceService, "findOneById").mockResolvedValue({
+    id: telemetryServiceId,
+    name: "checkout",
+    projectId: projectId,
+    ...overrides,
+  } as unknown as Service);
+}
+
+describe("TelemetryImprovementTaskTrigger.createTelemetryImprovementTask", () => {
+  beforeEach(() => {
+    jest
+      .spyOn(SubjectCodeFixRun, "hasGitHubAppConnectedRepository")
+      .mockResolvedValue(true);
+    jest
+      .spyOn(SubjectCodeFixRun, "findNonTerminalRunForTelemetryService")
+      .mockResolvedValue(null);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("rejects non-improvement recipes before touching anything", async () => {
+    const findService: jest.SpyInstance = jest.spyOn(
+      ServiceService,
+      "findOneById",
+    );
+
+    await expect(
+      TelemetryImprovementTaskTrigger.createTelemetryImprovementTask({
+        projectId,
+        telemetryServiceId,
+        taskType: CodeFixTaskType.FixException,
+        userId,
+      }),
+    ).rejects.toThrow(/not a telemetry-improvement recipe/);
+
+    expect(findService).not.toHaveBeenCalled();
+  });
+
+  test("rejects a service from another project (root read, explicit tenant check)", async () => {
+    mockService({ projectId: ObjectID.generate() });
+
+    await expect(
+      TelemetryImprovementTaskTrigger.createTelemetryImprovementTask({
+        projectId,
+        telemetryServiceId,
+        taskType: CodeFixTaskType.ImproveLogging,
+        userId,
+      }),
+    ).rejects.toThrow(/not found/);
+  });
+
+  test("rejects when no GitHub-App-connected repository exists", async () => {
+    mockService();
+    jest
+      .spyOn(SubjectCodeFixRun, "hasGitHubAppConnectedRepository")
+      .mockResolvedValue(false);
+
+    await expect(
+      TelemetryImprovementTaskTrigger.createTelemetryImprovementTask({
+        projectId,
+        telemetryServiceId,
+        taskType: CodeFixTaskType.ImproveLogging,
+        userId,
+      }),
+    ).rejects.toThrow(/GitHub-App-connected repository/);
+  });
+
+  test("per-(service, recipe) dedupe: an active run for the service blocks a second one", async () => {
+    mockService();
+    jest
+      .spyOn(SubjectCodeFixRun, "findNonTerminalRunForTelemetryService")
+      .mockResolvedValue({ id: ObjectID.generate() } as unknown as AIRun);
+    const enqueue: jest.SpyInstance = jest.spyOn(
+      SubjectCodeFixRun,
+      "enqueueSubjectCodeFixRun",
+    );
+
+    await expect(
+      TelemetryImprovementTaskTrigger.createTelemetryImprovementTask({
+        projectId,
+        telemetryServiceId,
+        taskType: CodeFixTaskType.ImproveTracing,
+        userId,
+      }),
+    ).rejects.toThrow(/already queued or running/);
+
+    expect(enqueue).not.toHaveBeenCalled();
+  });
+
+  test("happy path: enqueues with the service captured in taskContext and the user attributed", async () => {
+    mockService();
+    const createdRun: AIRun = { id: ObjectID.generate() } as unknown as AIRun;
+    const enqueue: jest.SpyInstance = jest
+      .spyOn(SubjectCodeFixRun, "enqueueSubjectCodeFixRun")
+      .mockResolvedValue(createdRun);
+
+    const run: AIRun =
+      await TelemetryImprovementTaskTrigger.createTelemetryImprovementTask({
+        projectId,
+        telemetryServiceId,
+        taskType: CodeFixTaskType.ImproveLogging,
+        userId,
+      });
+
+    expect(run).toBe(createdRun);
+    expect(enqueue).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectId,
+        taskType: CodeFixTaskType.ImproveLogging,
+        userId,
+        taskContext: expect.objectContaining({
+          telemetryServiceId: telemetryServiceId.toString(),
+          serviceName: "checkout",
+        }),
+      }),
+    );
+  });
+});

package/Tests/Types/AI/CodeFixTaskType.test.ts

@@ -9,6 +9,7 @@ describe("CodeFixTaskTypeHelper", () => {
       expect(CodeFixTaskTypeHelper.getUserTriggerableTaskTypes()).toEqual([
         CodeFixTaskType.FixException,
         CodeFixTaskType.WriteRegressionTest,
+        CodeFixTaskType.ImproveExceptionHandling,
       ]);
     });
   });
@@ -17,6 +18,7 @@ describe("CodeFixTaskTypeHelper", () => {
     test.each([
       CodeFixTaskType.FixException,
       CodeFixTaskType.WriteRegressionTest,
+      CodeFixTaskType.ImproveExceptionHandling,
     ])("returns true for %s", (taskType: CodeFixTaskType) => {
       expect(CodeFixTaskTypeHelper.isUserTriggerable(taskType)).toBe(true);
     });
@@ -69,6 +71,7 @@ describe("CodeFixTaskTypeHelper", () => {
     test.each([
       CodeFixTaskType.FixException,
       CodeFixTaskType.WriteRegressionTest,
+      CodeFixTaskType.ImproveExceptionHandling,
     ])("returns true for %s", (taskType: CodeFixTaskType) => {
       expect(CodeFixTaskTypeHelper.requiresTelemetryException(taskType)).toBe(
         true,

package/Tests/Types/Monitor/MonitorCriteriaMetricVariables.test.ts

@@ -0,0 +1,228 @@
+import MetricsAggregationType from "../../../Types/Metrics/MetricsAggregationType";
+import { CheckOn, CriteriaFilter } from "../../../Types/Monitor/CriteriaFilter";
+import { getAllCephAlertTemplates } from "../../../Types/Monitor/CephAlertTemplates";
+import { getAllDockerAlertTemplates } from "../../../Types/Monitor/DockerAlertTemplates";
+import { getAllDockerSwarmAlertTemplates } from "../../../Types/Monitor/DockerSwarmAlertTemplates";
+import {
+  buildHostMonitorConfig,
+  getAllHostAlertTemplates,
+} from "../../../Types/Monitor/HostAlertTemplates";
+import { getAllIoTAlertTemplates } from "../../../Types/Monitor/IotAlertTemplates";
+import { getAllKubernetesAlertTemplates } from "../../../Types/Monitor/KubernetesAlertTemplates";
+import { getAllPodmanAlertTemplates } from "../../../Types/Monitor/PodmanAlertTemplates";
+import { getAllProxmoxAlertTemplates } from "../../../Types/Monitor/ProxmoxAlertTemplates";
+import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInstance";
+import MonitorStep, {
+  MonitorStepType,
+} from "../../../Types/Monitor/MonitorStep";
+import MonitorStepHostMonitor from "../../../Types/Monitor/MonitorStepHostMonitor";
+import MonitorStepMetricViewConfigUtil from "../../../Types/Monitor/MonitorStepMetricViewConfigUtil";
+import RollingTime from "../../../Types/RollingTime/RollingTime";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * End-to-end regression guard for the blank "METRIC" dropdown (Issues 1 & 2).
+ *
+ * For EVERY metric-shaped monitor type, a Quick Setup alert template must
+ * produce a monitor step whose metric variables are discoverable through
+ * MonitorStepMetricViewConfigUtil — the same resolver the criteria UI uses to
+ * fill the "Which metric query should this alert rule check?" dropdown. And
+ * every MetricValue criteria the template emits must reference a variable that
+ * the dropdown actually offers, otherwise the alert rule points at a metric the
+ * user can never (re)select.
+ *
+ * Before the fix, Host / Podman / DockerSwarm / IoT would all fail the
+ * "surfaces at least one metric variable" assertion because the criteria UI
+ * never read their metricViewConfig.
+ */
+
+// Superset of every template's Args — excess fields are ignored per type.
+interface UniversalTemplateArgs {
+  hostIdentifier: string;
+  clusterIdentifier: string;
+  fleetIdentifier: string;
+  onlineMonitorStatusId: ObjectID;
+  offlineMonitorStatusId: ObjectID;
+  defaultIncidentSeverityId: ObjectID;
+  defaultAlertSeverityId: ObjectID;
+  monitorName: string;
+}
+
+interface AnyAlertTemplate {
+  id: string;
+  name: string;
+  getMonitorStep: (args: UniversalTemplateArgs) => MonitorStep;
+}
+
+interface ResourceDescriptor {
+  name: string;
+  subConfigKey: keyof MonitorStepType;
+  templates: Array<AnyAlertTemplate>;
+}
+
+function buildArgs(): UniversalTemplateArgs {
+  return {
+    hostIdentifier: "host-identifier-1",
+    clusterIdentifier: "cluster-identifier-1",
+    fleetIdentifier: "fleet-identifier-1",
+    onlineMonitorStatusId: ObjectID.generate(),
+    offlineMonitorStatusId: ObjectID.generate(),
+    defaultIncidentSeverityId: ObjectID.generate(),
+    defaultAlertSeverityId: ObjectID.generate(),
+    monitorName: "Test Monitor",
+  };
+}
+
+const RESOURCES: Array<ResourceDescriptor> = [
+  {
+    name: "Host",
+    subConfigKey: "hostMonitor",
+    templates: getAllHostAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+  {
+    name: "Kubernetes",
+    subConfigKey: "kubernetesMonitor",
+    templates:
+      getAllKubernetesAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+  {
+    name: "Docker",
+    subConfigKey: "dockerMonitor",
+    templates:
+      getAllDockerAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+  {
+    name: "DockerSwarm",
+    subConfigKey: "dockerSwarmMonitor",
+    templates:
+      getAllDockerSwarmAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+  {
+    name: "Podman",
+    subConfigKey: "podmanMonitor",
+    templates:
+      getAllPodmanAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+  {
+    name: "Proxmox",
+    subConfigKey: "proxmoxMonitor",
+    templates:
+      getAllProxmoxAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+  {
+    name: "Ceph",
+    subConfigKey: "cephMonitor",
+    templates: getAllCephAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+  {
+    name: "IoT",
+    subConfigKey: "iotMonitor",
+    templates: getAllIoTAlertTemplates() as unknown as Array<AnyAlertTemplate>,
+  },
+];
+
+function getCriteriaInstances(
+  step: MonitorStep,
+): Array<MonitorCriteriaInstance> {
+  return step.data?.monitorCriteria?.data?.monitorCriteriaInstanceArray || [];
+}
+
+describe("Monitor criteria metric-variable resolution (all resource types)", () => {
+  test("every resource type exposes at least one alert template", () => {
+    for (const resource of RESOURCES) {
+      expect(resource.templates.length).toBeGreaterThan(0);
+    }
+  });
+
+  describe.each(RESOURCES)(
+    "$name alert templates",
+    (resource: ResourceDescriptor) => {
+      test("the resolver reads this resource's metricViewConfig", () => {
+        const step: MonitorStep =
+          resource.templates[0]!.getMonitorStep(buildArgs());
+
+        const stepRecord: Record<
+          string,
+          { metricViewConfig?: unknown } | undefined
+        > = step.data as unknown as Record<
+          string,
+          { metricViewConfig?: unknown } | undefined
+        >;
+
+        const expectedConfig: unknown =
+          stepRecord[resource.subConfigKey as string]?.metricViewConfig;
+
+        expect(expectedConfig).toBeDefined();
+        expect(
+          MonitorStepMetricViewConfigUtil.getMetricViewConfig(step.data),
+        ).toBe(expectedConfig);
+      });
+
+      test.each(
+        resource.templates.map(
+          (t: AnyAlertTemplate): [string, AnyAlertTemplate] => {
+            return [t.id, t];
+          },
+        ),
+      )(
+        "%s surfaces metric variables and resolves its criteria aliases",
+        (_id: string, template: AnyAlertTemplate) => {
+          const step: MonitorStep = template.getMonitorStep(buildArgs());
+
+          // 1. The dropdown would offer at least one option (the actual bug).
+          const variables: Array<string> =
+            MonitorStepMetricViewConfigUtil.getMetricVariables(step.data);
+          expect(variables.length).toBeGreaterThan(0);
+          // No blank options leak through.
+          expect(variables).not.toContain("");
+
+          // 2. Every MetricValue criteria references an offered variable.
+          const referencedAliases: Set<string> = new Set<string>();
+          for (const instance of getCriteriaInstances(step)) {
+            for (const filter of (instance.data?.filters ||
+              []) as Array<CriteriaFilter>) {
+              if (
+                filter.checkOn === CheckOn.MetricValue &&
+                filter.metricMonitorOptions?.metricAlias
+              ) {
+                referencedAliases.add(filter.metricMonitorOptions.metricAlias);
+              }
+            }
+          }
+
+          // These templates must produce at least one metric criteria.
+          expect(referencedAliases.size).toBeGreaterThan(0);
+
+          for (const alias of referencedAliases) {
+            expect(variables).toContain(alias);
+          }
+        },
+      );
+    },
+  );
+});
+
+describe("Custom Metric flow (buildHostMonitorConfig)", () => {
+  test("a long descriptive alias is surfaced by the resolver", () => {
+    const config: MonitorStepHostMonitor = buildHostMonitorConfig({
+      hostIdentifier: "host-1",
+      metricName: "process.cpu.utilization",
+      metricAlias: "process_cpu_utilization",
+      rollingTime: RollingTime.Past5Minutes,
+      aggregationType: MetricsAggregationType.Max,
+    });
+
+    const stepData: MonitorStepType = {
+      hostMonitor: config,
+    } as unknown as MonitorStepType;
+
+    expect(
+      MonitorStepMetricViewConfigUtil.getMetricVariables(stepData),
+    ).toEqual(["process_cpu_utilization"]);
+
+    // The alias also lands on the query config so the criteria join key holds.
+    expect(
+      config.metricViewConfig.queryConfigs[0]?.metricAliasData?.metricVariable,
+    ).toBe("process_cpu_utilization");
+  });
+});

package/Tests/Types/Monitor/MonitorStepDefaultTelemetryConfig.test.ts

@@ -0,0 +1,169 @@
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import { MonitorStepLogMonitorUtil } from "../../../Types/Monitor/MonitorStepLogMonitor";
+import { MonitorStepTraceMonitorUtil } from "../../../Types/Monitor/MonitorStepTraceMonitor";
+import { MonitorStepMetricMonitorUtil } from "../../../Types/Monitor/MonitorStepMetricMonitor";
+import { MonitorStepExceptionMonitorUtil } from "../../../Types/Monitor/MonitorStepExceptionMonitor";
+
+/*
+ * Regression coverage for the "log monitors do not work" bug: a telemetry
+ * monitor step created on defaults must persist its own type's sub-config
+ * (logMonitor / traceMonitor / metricMonitor / exceptionMonitor) rather than
+ * leaving it undefined. When it was left undefined, the worker's
+ * monitorLogs()/monitorTrace()/... threw "<type> query/config is missing" on
+ * every evaluation, so the monitor never ran and its criteria never applied.
+ */
+describe("MonitorStep.getDefaultMonitorStep telemetry sub-config seeding", () => {
+  const buildArgs: (
+    monitorType: MonitorType,
+  ) => Parameters<typeof MonitorStep.getDefaultMonitorStep>[0] = (
+    monitorType: MonitorType,
+  ) => {
+    const id: ObjectID = ObjectID.generate();
+    return {
+      monitorName: `${monitorType} monitor`,
+      monitorType,
+      onlineMonitorStatusId: id,
+      offlineMonitorStatusId: id,
+      defaultIncidentSeverityId: id,
+      defaultAlertSeverityId: id,
+    };
+  };
+
+  describe("seeds exactly the matching type's sub-config", () => {
+    test("Logs monitor seeds logMonitor equal to its util default", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep(
+        buildArgs(MonitorType.Logs),
+      );
+
+      expect(step.data?.logMonitor).toBeDefined();
+      expect(step.data?.logMonitor).toEqual(
+        MonitorStepLogMonitorUtil.getDefault(),
+      );
+      // The default query config must be usable (positive time window).
+      expect(step.data?.logMonitor?.lastXSecondsOfLogs).toBeGreaterThan(0);
+      expect(step.data?.traceMonitor).toBeUndefined();
+      expect(step.data?.metricMonitor).toBeUndefined();
+      expect(step.data?.exceptionMonitor).toBeUndefined();
+    });
+
+    test("Traces monitor seeds traceMonitor equal to its util default", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep(
+        buildArgs(MonitorType.Traces),
+      );
+
+      expect(step.data?.traceMonitor).toBeDefined();
+      expect(step.data?.traceMonitor).toEqual(
+        MonitorStepTraceMonitorUtil.getDefault(),
+      );
+      expect(step.data?.traceMonitor?.lastXSecondsOfSpans).toBeGreaterThan(0);
+      expect(step.data?.logMonitor).toBeUndefined();
+      expect(step.data?.metricMonitor).toBeUndefined();
+      expect(step.data?.exceptionMonitor).toBeUndefined();
+    });
+
+    test("Metrics monitor seeds metricMonitor equal to its util default", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep(
+        buildArgs(MonitorType.Metrics),
+      );
+
+      expect(step.data?.metricMonitor).toBeDefined();
+      expect(step.data?.metricMonitor).toEqual(
+        MonitorStepMetricMonitorUtil.getDefault(),
+      );
+      expect(step.data?.metricMonitor?.metricViewConfig).toBeDefined();
+      expect(step.data?.logMonitor).toBeUndefined();
+      expect(step.data?.traceMonitor).toBeUndefined();
+      expect(step.data?.exceptionMonitor).toBeUndefined();
+    });
+
+    test("Exceptions monitor seeds exceptionMonitor equal to its util default", () => {
+      const step: MonitorStep = MonitorStep.getDefaultMonitorStep(
+        buildArgs(MonitorType.Exceptions),
+      );
+
+      expect(step.data?.exceptionMonitor).toBeDefined();
+      expect(step.data?.exceptionMonitor).toEqual(
+        MonitorStepExceptionMonitorUtil.getDefault(),
+      );
+      expect(step.data?.logMonitor).toBeUndefined();
+      expect(step.data?.traceMonitor).toBeUndefined();
+      expect(step.data?.metricMonitor).toBeUndefined();
+    });
+  });
+
+  describe("does not seed a telemetry sub-config for other types", () => {
+    /*
+     * Only the four telemetry types offered by the Telemetry picker are
+     * seeded here. Infra metric monitors (Kubernetes/Docker/Host/...) carry
+     * their own sub-config from templates, and non-telemetry monitors have
+     * no telemetry sub-config at all — none must get a logMonitor/traceMonitor
+     * /metricMonitor/exceptionMonitor from the generic default step.
+     */
+    const nonSeededTypes: Array<MonitorType> = [
+      MonitorType.Ping,
+      MonitorType.IP,
+      MonitorType.Port,
+      MonitorType.Website,
+      MonitorType.API,
+      MonitorType.Server,
+      MonitorType.SSLCertificate,
+      MonitorType.IncomingRequest,
+      MonitorType.SyntheticMonitor,
+      MonitorType.CustomJavaScriptCode,
+      MonitorType.SQLQuery,
+      MonitorType.Manual,
+      MonitorType.Profiles,
+      MonitorType.Kubernetes,
+      MonitorType.Docker,
+      MonitorType.Host,
+      MonitorType.Podman,
+      MonitorType.DockerSwarm,
+      MonitorType.Proxmox,
+      MonitorType.Ceph,
+      MonitorType.IoTDevice,
+    ];
+
+    test.each(nonSeededTypes)(
+      "%s seeds no telemetry sub-config",
+      (monitorType: MonitorType) => {
+        const step: MonitorStep = MonitorStep.getDefaultMonitorStep(
+          buildArgs(monitorType),
+        );
+
+        expect(step.data?.logMonitor).toBeUndefined();
+        expect(step.data?.traceMonitor).toBeUndefined();
+        expect(step.data?.metricMonitor).toBeUndefined();
+        expect(step.data?.exceptionMonitor).toBeUndefined();
+      },
+    );
+  });
+
+  test("still seeds the default criteria and a step id", () => {
+    const step: MonitorStep = MonitorStep.getDefaultMonitorStep(
+      buildArgs(MonitorType.Logs),
+    );
+
+    expect(step.data?.id).toBeDefined();
+    expect(step.data?.monitorCriteria).toBeDefined();
+    expect(
+      step.data?.monitorCriteria.data?.monitorCriteriaInstanceArray.length,
+    ).toBeGreaterThan(0);
+  });
+
+  test("seeds a fresh sub-config object per call (no shared mutable state)", () => {
+    const a: MonitorStep = MonitorStep.getDefaultMonitorStep(
+      buildArgs(MonitorType.Logs),
+    );
+    const b: MonitorStep = MonitorStep.getDefaultMonitorStep(
+      buildArgs(MonitorType.Logs),
+    );
+
+    expect(a.data?.logMonitor).not.toBe(b.data?.logMonitor);
+
+    // Mutating one must not bleed into the other.
+    a.data!.logMonitor!.lastXSecondsOfLogs = 999;
+    expect(b.data?.logMonitor?.lastXSecondsOfLogs).not.toBe(999);
+  });
+});