@oneuptime/common 11.5.13 → 11.6.1

package/Tests/Server/Utils/Marketing/GoogleAds.test.ts

@@ -0,0 +1,340 @@
+import MarketingConversion from "../../../../Models/DatabaseModels/MarketingConversion";
+import logger from "../../../../Server/Utils/Logger";
+import GoogleAdsProvider from "../../../../Server/Utils/Marketing/Providers/GoogleAds";
+import { ConversionUploadBatchResult } from "../../../../Server/Utils/Marketing/ConversionUploadProvider";
+import { JSONObject } from "../../../../Types/JSON";
+import { MarketingConversionType } from "../../../../Types/Marketing/MarketingConversion";
+import axios, { AxiosResponse } from "axios";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { SpyInstance } from "jest-mock";
+
+jest.mock("../../../../Server/EnvironmentConfig", () => {
+  return {
+    GoogleAdsApiVersion: "v23",
+    GoogleAdsCustomerId: "1234567890",
+    GoogleAdsDeveloperToken: "developer-token",
+    GoogleAdsLoginCustomerId: "0987654321",
+    GoogleAdsOAuthClientId: "oauth-client-id",
+    GoogleAdsOAuthClientSecret: "oauth-client-secret",
+    GoogleAdsOAuthRefreshToken: "oauth-refresh-token",
+    GoogleAdsPaidSubscriptionConversionActionId: "222222",
+    GoogleAdsSignUpConversionActionId: "111111",
+  };
+});
+
+jest.mock("../../../../Server/Utils/Logger", () => {
+  return {
+    __esModule: true,
+    default: {
+      error: jest.fn(),
+    },
+  };
+});
+
+const makeConversion: (
+  data?: Partial<MarketingConversion>,
+) => MarketingConversion = (
+  data: Partial<MarketingConversion> = {},
+): MarketingConversion => {
+  return Object.assign(new MarketingConversion(), {
+    conversionType: MarketingConversionType.SignUp,
+    conversionAt: new Date("2026-07-22T10:11:12.345Z"),
+    clickIds: { gclid: "google-click" },
+    ...data,
+  });
+};
+
+const response: (data: JSONObject) => AxiosResponse<JSONObject> = (
+  data: JSONObject,
+): AxiosResponse<JSONObject> => {
+  return { data } as AxiosResponse<JSONObject>;
+};
+
+describe("GoogleAdsProvider", () => {
+  let provider: GoogleAdsProvider;
+  let postSpy: SpyInstance<any>;
+
+  beforeEach(() => {
+    provider = new GoogleAdsProvider();
+    postSpy = jest.spyOn(axios, "post") as SpyInstance<any>;
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("reports configured only when the OAuth and account settings exist", () => {
+    expect(provider.isConfigured()).toBe(true);
+  });
+
+  test("permanently skips conversions without a Google click identifier", () => {
+    expect(
+      provider.getSkipReason(makeConversion({ clickIds: { fbclid: "meta" } })),
+    ).toEqual({
+      reason: "No Google click id (gclid/wbraid/gbraid)",
+      isPermanent: true,
+    });
+  });
+
+  test.each([
+    ["gclid", "standard-click"],
+    ["wbraid", "web-to-app-click"],
+    ["gbraid", "app-to-web-click"],
+  ])("accepts the supported %s identifier", (key: string, value: string) => {
+    expect(
+      provider.getSkipReason(makeConversion({ clickIds: { [key]: value } })),
+    ).toBeNull();
+  });
+
+  test("prefers gclid when multiple Google identifiers are present", async () => {
+    postSpy
+      .mockResolvedValueOnce(
+        response({ access_token: "access-token", expires_in: 3600 }) as never,
+      )
+      .mockResolvedValueOnce(response({}) as never);
+
+    await provider.upload([
+      makeConversion({
+        clickIds: {
+          gclid: "preferred-gclid",
+          wbraid: "secondary-wbraid",
+          gbraid: "secondary-gbraid",
+        },
+      }),
+    ]);
+
+    const uploadBody: JSONObject = postSpy.mock.calls[1]?.[1] as JSONObject;
+    const uploadedConversion: JSONObject = (
+      uploadBody["conversions"] as Array<JSONObject>
+    )[0]!;
+
+    expect(uploadedConversion).toMatchObject({ gclid: "preferred-gclid" });
+    expect(uploadedConversion["wbraid"]).toBeUndefined();
+    expect(uploadedConversion["gbraid"]).toBeUndefined();
+  });
+
+  test("permanently skips conversions outside Google's 90-day window", () => {
+    jest
+      .spyOn(Date, "now")
+      .mockReturnValue(new Date("2026-07-22T12:00:00.000Z").getTime());
+
+    expect(
+      provider.getSkipReason(
+        makeConversion({
+          conversionAt: new Date("2026-04-01T00:00:00.000Z"),
+        }),
+      ),
+    ).toEqual({
+      reason: "Conversion older than Google's 90-day click window",
+      isPermanent: true,
+    });
+  });
+
+  test("uploads signup and paid conversions with the correct actions and value", async () => {
+    postSpy
+      .mockResolvedValueOnce(
+        response({ access_token: "access-token", expires_in: 3600 }) as never,
+      )
+      .mockResolvedValueOnce(response({}) as never);
+
+    const result: ConversionUploadBatchResult = await provider.upload([
+      makeConversion({
+        conversionType: MarketingConversionType.SignUp,
+        clickIds: { wbraid: "signup-wbraid" },
+      }),
+      makeConversion({
+        conversionType: MarketingConversionType.PaidSubscription,
+        clickIds: { gbraid: "paid-gbraid" },
+        conversionValueInUSDCents: 12999,
+      }),
+    ]);
+
+    expect(result.permanentFailures.size).toBe(0);
+    expect(postSpy).toHaveBeenCalledTimes(2);
+    expect(postSpy.mock.calls[0]?.[0]).toBe(
+      "https://oauth2.googleapis.com/token",
+    );
+    expect(postSpy.mock.calls[0]?.[1]).toContain(
+      "refresh_token=oauth-refresh-token",
+    );
+
+    const uploadUrl: string = postSpy.mock.calls[1]?.[0] as string;
+    const uploadBody: JSONObject = postSpy.mock.calls[1]?.[1] as JSONObject;
+    const uploadOptions: JSONObject = postSpy.mock.calls[1]?.[2] as JSONObject;
+    const conversions: Array<JSONObject> = uploadBody[
+      "conversions"
+    ] as Array<JSONObject>;
+
+    expect(uploadUrl).toBe(
+      "https://googleads.googleapis.com/v23/customers/1234567890:uploadClickConversions",
+    );
+    expect(uploadBody["partialFailure"]).toBe(true);
+    expect(conversions[0]).toEqual({
+      wbraid: "signup-wbraid",
+      conversionAction: "customers/1234567890/conversionActions/111111",
+      conversionDateTime: "2026-07-22 10:11:12+00:00",
+    });
+    expect(conversions[1]).toEqual({
+      gbraid: "paid-gbraid",
+      conversionAction: "customers/1234567890/conversionActions/222222",
+      conversionDateTime: "2026-07-22 10:11:12+00:00",
+      conversionValue: 129.99,
+      currencyCode: "USD",
+    });
+    expect(uploadOptions).toMatchObject({
+      headers: {
+        Authorization: "Bearer access-token",
+        "developer-token": "developer-token",
+        "login-customer-id": "0987654321",
+      },
+      timeout: 30000,
+    });
+  });
+
+  test("does not send zero or negative conversion values", async () => {
+    postSpy
+      .mockResolvedValueOnce(
+        response({ access_token: "access-token", expires_in: 3600 }) as never,
+      )
+      .mockResolvedValueOnce(response({}) as never);
+
+    await provider.upload([
+      makeConversion({ conversionValueInUSDCents: 0 }),
+      makeConversion({ conversionValueInUSDCents: -100 }),
+    ]);
+
+    const uploadBody: JSONObject = postSpy.mock.calls[1]?.[1] as JSONObject;
+    const conversions: Array<JSONObject> = uploadBody[
+      "conversions"
+    ] as Array<JSONObject>;
+
+    expect(conversions[0]?.["conversionValue"]).toBeUndefined();
+    expect(conversions[0]?.["currencyCode"]).toBeUndefined();
+    expect(conversions[1]?.["conversionValue"]).toBeUndefined();
+  });
+
+  test("reuses an unexpired OAuth access token across batches", async () => {
+    postSpy
+      .mockResolvedValueOnce(
+        response({ access_token: "cached-token", expires_in: 3600 }) as never,
+      )
+      .mockResolvedValue(response({}) as never);
+
+    await provider.upload([makeConversion()]);
+    await provider.upload([makeConversion({ clickIds: { gclid: "second" } })]);
+
+    expect(postSpy).toHaveBeenCalledTimes(3);
+    expect(
+      postSpy.mock.calls.filter((call: Array<unknown>) => {
+        return call[0] === "https://oauth2.googleapis.com/token";
+      }),
+    ).toHaveLength(1);
+  });
+
+  test("maps indexed partial failures to the submitted conversion", async () => {
+    postSpy
+      .mockResolvedValueOnce(
+        response({ access_token: "access-token", expires_in: 3600 }) as never,
+      )
+      .mockResolvedValueOnce(
+        response({
+          partialFailureError: {
+            details: [
+              {
+                errors: [
+                  {
+                    message: "Expired click identifier",
+                    location: {
+                      fieldPathElements: [
+                        { fieldName: "conversions", index: 1 },
+                      ],
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        }) as never,
+      );
+
+    const result: ConversionUploadBatchResult = await provider.upload([
+      makeConversion(),
+      makeConversion({ clickIds: { gclid: "expired" } }),
+    ]);
+
+    expect(Array.from(result.permanentFailures.entries())).toEqual([
+      [1, "Expired click identifier"],
+    ]);
+  });
+
+  test("treats ALREADY_EXISTS as successful idempotent delivery", async () => {
+    postSpy
+      .mockResolvedValueOnce(
+        response({ access_token: "access-token", expires_in: 3600 }) as never,
+      )
+      .mockResolvedValueOnce(
+        response({
+          partialFailureError: {
+            details: [
+              {
+                errors: [
+                  {
+                    errorCode: { conversionUploadError: "ALREADY_EXISTS" },
+                    message: "The conversion was already uploaded",
+                    location: {
+                      fieldPathElements: [
+                        { fieldName: "conversions", index: 0 },
+                      ],
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        }) as never,
+      );
+
+    const result: ConversionUploadBatchResult = await provider.upload([
+      makeConversion(),
+    ]);
+
+    expect(result.permanentFailures.size).toBe(0);
+  });
+
+  test("logs an unparseable partial failure instead of silently hiding it", async () => {
+    const errorSpy: SpyInstance<typeof logger.error> = jest
+      .spyOn(logger, "error")
+      .mockImplementation((): void => {
+        return undefined;
+      });
+    postSpy
+      .mockResolvedValueOnce(
+        response({ access_token: "access-token", expires_in: 3600 }) as never,
+      )
+      .mockResolvedValueOnce(
+        response({
+          partialFailureError: {
+            details: [{ errors: [{ message: "Unindexed failure" }] }],
+          },
+        }) as never,
+      );
+
+    const result: ConversionUploadBatchResult = await provider.upload([
+      makeConversion(),
+    ]);
+
+    expect(result.permanentFailures.size).toBe(0);
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        "Google Ads partial failure with unparseable indexes",
+      ),
+    );
+  });
+});

package/Tests/Server/Utils/Monitor/Criteria/ExceptionMonitorCriteria.test.ts

@@ -0,0 +1,87 @@
+import ExceptionMonitorCriteria from "../../../../../Server/Utils/Monitor/Criteria/ExceptionMonitorCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../../../Types/Monitor/CriteriaFilter";
+import ExceptionMonitorResponse from "../../../../../Types/Monitor/ExceptionMonitor/ExceptionMonitorResponse";
+import DataToProcess from "../../../../../Server/Utils/Monitor/DataToProcess";
+import ObjectID from "../../../../../Types/ObjectID";
+
+/*
+ * ExceptionMonitorCriteria is the ExceptionCount analogue of
+ * LogMonitorCriteria and shares the same fallback-fixed worker path
+ * (monitorException). Covered here for parity across the count-based
+ * telemetry criteria.
+ */
+function buildResponse(exceptionCount: number | undefined): DataToProcess {
+  const response: Partial<ExceptionMonitorResponse> = {
+    projectId: ObjectID.generate(),
+    monitorId: ObjectID.generate(),
+    exceptionCount: exceptionCount as number,
+    exceptionQuery: {},
+  };
+  return response as DataToProcess;
+}
+
+function evaluate(
+  exceptionCount: number | undefined,
+  criteriaFilter: CriteriaFilter,
+): Promise<string | null> {
+  return ExceptionMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+    dataToProcess: buildResponse(exceptionCount),
+    criteriaFilter,
+  });
+}
+
+describe("ExceptionMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
+  test("ExceptionCount GreaterThan 0 → met when exceptions exist", async () => {
+    expect(
+      await evaluate(3, {
+        checkOn: CheckOn.ExceptionCount,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+    ).toBeTruthy();
+  });
+
+  test("ExceptionCount EqualTo 0 → met when there are none (default)", async () => {
+    expect(
+      await evaluate(0, {
+        checkOn: CheckOn.ExceptionCount,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      }),
+    ).toBeTruthy();
+  });
+
+  test("ExceptionCount GreaterThan → not met when none", async () => {
+    expect(
+      await evaluate(0, {
+        checkOn: CheckOn.ExceptionCount,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+    ).toBeNull();
+  });
+
+  test("a missing exceptionCount is treated as 0", async () => {
+    expect(
+      await evaluate(undefined, {
+        checkOn: CheckOn.ExceptionCount,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      }),
+    ).toBeTruthy();
+  });
+
+  test("a non-ExceptionCount checkOn returns null (unhandled)", async () => {
+    expect(
+      await evaluate(9, {
+        checkOn: CheckOn.LogCount,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+    ).toBeNull();
+  });
+});

package/Tests/Server/Utils/Monitor/Criteria/LogMonitorCriteria.test.ts

@@ -0,0 +1,165 @@
+import LogMonitorCriteria from "../../../../../Server/Utils/Monitor/Criteria/LogMonitorCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../../../Types/Monitor/CriteriaFilter";
+import LogMonitorResponse from "../../../../../Types/Monitor/LogMonitor/LogMonitorResponse";
+import DataToProcess from "../../../../../Server/Utils/Monitor/DataToProcess";
+import ObjectID from "../../../../../Types/ObjectID";
+
+/*
+ * LogMonitorCriteria is what turns the logCount the (now-fixed) worker
+ * produces into an online/offline verdict. It only understands
+ * CheckOn.LogCount — the sole check the Logs criteria UI offers — and defers
+ * the numeric comparison to CompareCriteria.
+ */
+function buildResponse(logCount: number | undefined): DataToProcess {
+  const response: Partial<LogMonitorResponse> = {
+    projectId: ObjectID.generate(),
+    monitorId: ObjectID.generate(),
+    logCount: logCount as number,
+    logQuery: {},
+  };
+  return response as DataToProcess;
+}
+
+function evaluate(
+  logCount: number | undefined,
+  criteriaFilter: CriteriaFilter,
+): Promise<string | null> {
+  return LogMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+    dataToProcess: buildResponse(logCount),
+    criteriaFilter,
+  });
+}
+
+describe("LogMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
+  describe("LogCount GreaterThan", () => {
+    test("count above threshold → met", async () => {
+      const result: string | null = await evaluate(5, {
+        checkOn: CheckOn.LogCount,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      });
+      expect(result).toBeTruthy();
+      expect(result).toContain("Log Count");
+    });
+
+    test("count equal to threshold → not met", async () => {
+      expect(
+        await evaluate(3, {
+          checkOn: CheckOn.LogCount,
+          filterType: FilterType.GreaterThan,
+          value: 3,
+        }),
+      ).toBeNull();
+    });
+
+    test("count below threshold → not met", async () => {
+      expect(
+        await evaluate(0, {
+          checkOn: CheckOn.LogCount,
+          filterType: FilterType.GreaterThan,
+          value: 0,
+        }),
+      ).toBeNull();
+    });
+  });
+
+  describe("LogCount EqualTo (the default offline criteria)", () => {
+    test("zero logs equal to 0 → met (monitor goes offline)", async () => {
+      const result: string | null = await evaluate(0, {
+        checkOn: CheckOn.LogCount,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      });
+      expect(result).toBeTruthy();
+    });
+
+    test("some logs not equal to 0 → not met", async () => {
+      expect(
+        await evaluate(7, {
+          checkOn: CheckOn.LogCount,
+          filterType: FilterType.EqualTo,
+          value: 0,
+        }),
+      ).toBeNull();
+    });
+  });
+
+  describe("other numeric comparators", () => {
+    test("LessThan → met when below", async () => {
+      expect(
+        await evaluate(2, {
+          checkOn: CheckOn.LogCount,
+          filterType: FilterType.LessThan,
+          value: 5,
+        }),
+      ).toBeTruthy();
+    });
+
+    test("GreaterThanOrEqualTo → met at the boundary", async () => {
+      expect(
+        await evaluate(5, {
+          checkOn: CheckOn.LogCount,
+          filterType: FilterType.GreaterThanOrEqualTo,
+          value: 5,
+        }),
+      ).toBeTruthy();
+    });
+
+    test("LessThanOrEqualTo → met at the boundary", async () => {
+      expect(
+        await evaluate(5, {
+          checkOn: CheckOn.LogCount,
+          filterType: FilterType.LessThanOrEqualTo,
+          value: 5,
+        }),
+      ).toBeTruthy();
+    });
+
+    test("NotEqualTo → met when different", async () => {
+      expect(
+        await evaluate(4, {
+          checkOn: CheckOn.LogCount,
+          filterType: FilterType.NotEqualTo,
+          value: 0,
+        }),
+      ).toBeTruthy();
+    });
+  });
+
+  describe("edge cases", () => {
+    test("a missing logCount is treated as 0", async () => {
+      // undefined logCount → 0; "equal to 0" is therefore met.
+      expect(
+        await evaluate(undefined, {
+          checkOn: CheckOn.LogCount,
+          filterType: FilterType.EqualTo,
+          value: 0,
+        }),
+      ).toBeTruthy();
+    });
+
+    test("a string threshold is coerced to a number", async () => {
+      expect(
+        await evaluate(10, {
+          checkOn: CheckOn.LogCount,
+          filterType: FilterType.GreaterThan,
+          value: "5",
+        }),
+      ).toBeTruthy();
+    });
+
+    test("a non-LogCount checkOn returns null (unhandled)", async () => {
+      expect(
+        await evaluate(100, {
+          checkOn: CheckOn.SpanCount,
+          filterType: FilterType.GreaterThan,
+          value: 0,
+        }),
+      ).toBeNull();
+    });
+  });
+});

package/Tests/Server/Utils/Monitor/Criteria/TraceMonitorCriteria.test.ts

@@ -0,0 +1,86 @@
+import TraceMonitorCriteria from "../../../../../Server/Utils/Monitor/Criteria/TraceMonitorCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../../../Types/Monitor/CriteriaFilter";
+import TraceMonitorResponse from "../../../../../Types/Monitor/TraceMonitor/TraceMonitorResponse";
+import DataToProcess from "../../../../../Server/Utils/Monitor/DataToProcess";
+import ObjectID from "../../../../../Types/ObjectID";
+
+/*
+ * TraceMonitorCriteria is the SpanCount analogue of LogMonitorCriteria and
+ * shares the same fallback-fixed worker path (monitorTrace). Covered here for
+ * parity so the two count-based telemetry criteria stay in lock-step.
+ */
+function buildResponse(spanCount: number | undefined): DataToProcess {
+  const response: Partial<TraceMonitorResponse> = {
+    projectId: ObjectID.generate(),
+    monitorId: ObjectID.generate(),
+    spanCount: spanCount as number,
+    spanQuery: {},
+  };
+  return response as DataToProcess;
+}
+
+function evaluate(
+  spanCount: number | undefined,
+  criteriaFilter: CriteriaFilter,
+): Promise<string | null> {
+  return TraceMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+    dataToProcess: buildResponse(spanCount),
+    criteriaFilter,
+  });
+}
+
+describe("TraceMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
+  test("SpanCount GreaterThan → met when above threshold", async () => {
+    expect(
+      await evaluate(9, {
+        checkOn: CheckOn.SpanCount,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+    ).toBeTruthy();
+  });
+
+  test("SpanCount EqualTo 0 → met when no spans (offline)", async () => {
+    expect(
+      await evaluate(0, {
+        checkOn: CheckOn.SpanCount,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      }),
+    ).toBeTruthy();
+  });
+
+  test("SpanCount GreaterThan → not met at/below threshold", async () => {
+    expect(
+      await evaluate(0, {
+        checkOn: CheckOn.SpanCount,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+    ).toBeNull();
+  });
+
+  test("a missing spanCount is treated as 0", async () => {
+    expect(
+      await evaluate(undefined, {
+        checkOn: CheckOn.SpanCount,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      }),
+    ).toBeTruthy();
+  });
+
+  test("a non-SpanCount checkOn returns null (unhandled)", async () => {
+    expect(
+      await evaluate(50, {
+        checkOn: CheckOn.LogCount,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+    ).toBeNull();
+  });
+});