@oneuptime/common 12.0.14 → 12.0.15

package/Tests/Utils/Analytics.test.ts

@@ -107,3 +107,190 @@ describe("Analytics Class", () => {
     expect(posthog.capture).not.toHaveBeenCalled();
   });
 });
+
+describe("Analytics.toGA4EventName", () => {
+  /*
+   * GA4 event names must start with a letter and contain only letters, digits
+   * and underscores, with a maximum length of 40 characters.
+   */
+  const GA4_EVENT_NAME_REGEX: RegExp = /^[a-z][a-z0-9_]*$/;
+
+  it.each([
+    // Names product code sends today that GA4 would otherwise reject.
+    ["Page View: Project > Home", "page_view_project_home"],
+    ["FORM SUBMIT: Register", "form_submit_register"],
+    ["accounts/login", "accounts_login"],
+    ["accounts/register", "accounts_register"],
+    ["dashboard/home", "dashboard_home"],
+    ["dashboard/ai-copilot", "dashboard_ai_copilot"],
+    ["dashboard/billing/plan-changed", "dashboard_billing_plan_changed"],
+    [
+      "dashboard/home/getting-started-task",
+      "dashboard_home_getting_started_task",
+    ],
+    [
+      "dashboard/home/getting-started-dismissed",
+      "dashboard_home_getting_started_dismissed",
+    ],
+    // Leading and trailing separators are dropped rather than kept.
+    ["  /accounts/login/  ", "accounts_login"],
+    // A name with no leading letter gets a prefix.
+    ["404 page not found", "event_404_page_not_found"],
+    ["_leading_underscore", "leading_underscore"],
+    // A name with nothing usable in it falls back entirely.
+    ["***", "event"],
+    ["", "event"],
+    // Casing is normalised.
+    ["testEvent", "testevent"],
+  ])("normalises %j to %j", (input: string, expected: string) => {
+    expect(Analytics.toGA4EventName(input)).toBe(expected);
+  });
+
+  it("truncates to 40 characters without leaving a trailing underscore", () => {
+    const normalized: string = Analytics.toGA4EventName(
+      "Page View: Project > Settings > Notification > Email",
+    );
+
+    expect(normalized).toBe("page_view_project_settings_notification");
+    expect(normalized.length).toBeLessThanOrEqual(40);
+  });
+
+  it("truncates a name that is exactly at the boundary", () => {
+    const normalized: string = Analytics.toGA4EventName(
+      "Page View: Project > Settings > Notifications > Email",
+    );
+
+    expect(normalized).toBe("page_view_project_settings_notifications");
+    expect(normalized).toHaveLength(40);
+  });
+
+  it("leaves already GA4-compatible revenue event names untouched", () => {
+    for (const eventName of Object.values(RevenueEventName)) {
+      expect(Analytics.toGA4EventName(eventName)).toBe(eventName);
+    }
+  });
+
+  it("always produces a GA4-valid name", () => {
+    const inputs: Array<string> = [
+      "Page View: Project > Home",
+      "FORM SUBMIT: Register",
+      "accounts/login",
+      "404",
+      "___",
+      "!!!",
+      "",
+      "  ",
+      "a".repeat(200),
+      "1".repeat(200),
+      "Page View: " + "Very Long Breadcrumb > ".repeat(10),
+    ];
+
+    for (const input of inputs) {
+      const normalized: string = Analytics.toGA4EventName(input);
+
+      expect(normalized).toMatch(GA4_EVENT_NAME_REGEX);
+      expect(normalized.length).toBeGreaterThan(0);
+      expect(normalized.length).toBeLessThanOrEqual(40);
+      // Normalising an already-normalised name must be a no-op.
+      expect(Analytics.toGA4EventName(normalized)).toBe(normalized);
+    }
+  });
+});
+
+describe("Analytics dataLayer (GA4) branch", () => {
+  let dataLayer: Array<JSONObject>;
+
+  beforeEach(() => {
+    dataLayer = [];
+    (window as any).dataLayer = dataLayer;
+  });
+
+  afterEach(() => {
+    delete (window as any).dataLayer;
+    jest.clearAllMocks();
+  });
+
+  it("pushes a normalised event name while PostHog keeps the original", () => {
+    const analytics: Analytics = new Analytics(apiHost, apiKey);
+
+    analytics.capture("Page View: Project > Home");
+
+    expect(posthog.capture).toHaveBeenCalledWith(
+      "Page View: Project > Home",
+      undefined,
+    );
+    expect(dataLayer).toHaveLength(1);
+    expect(dataLayer[0]).toEqual({
+      event: "page_view_project_home",
+      eventCategory: "analytics",
+      eventAction: "Page View: Project > Home",
+    });
+  });
+
+  it("pushes to the dataLayer even when PostHog is not initialized", () => {
+    const analytics: Analytics = new Analytics("", "");
+
+    analytics.capture("FORM SUBMIT: Register");
+
+    expect(posthog.capture).not.toHaveBeenCalled();
+    expect(dataLayer).toHaveLength(1);
+    expect(dataLayer[0]).toMatchObject({
+      event: "form_submit_register",
+      eventAction: "FORM SUBMIT: Register",
+    });
+  });
+
+  it("includes event properties in the pushed payload", () => {
+    const analytics: Analytics = new Analytics(apiHost, apiKey);
+
+    analytics.capture("dashboard/billing/plan-changed", {
+      plan_name: "growth",
+      is_paid_conversion: true,
+    });
+
+    expect(dataLayer[0]).toEqual({
+      event: "dashboard_billing_plan_changed",
+      eventCategory: "analytics",
+      eventAction: "dashboard/billing/plan-changed",
+      plan_name: "growth",
+      is_paid_conversion: true,
+    });
+  });
+
+  it("does not let event properties override the GA4 event name", () => {
+    const analytics: Analytics = new Analytics(apiHost, apiKey);
+
+    analytics.capture("accounts/login", { event: "Not A Valid GA4 Name" });
+
+    expect(dataLayer[0]).toMatchObject({ event: "accounts_login" });
+  });
+
+  it("pushes revenue event names unchanged", () => {
+    const analytics: Analytics = new Analytics(apiHost, apiKey);
+
+    analytics.captureRevenueEvent(RevenueEventName.WorkspaceCreated, {
+      funnel_stage: RevenueFunnelStage.Activation,
+      project_id: "project-123",
+    });
+
+    expect(dataLayer[0]).toEqual({
+      event: RevenueEventName.WorkspaceCreated,
+      eventCategory: "analytics",
+      eventAction: RevenueEventName.WorkspaceCreated,
+      funnel_stage: RevenueFunnelStage.Activation,
+      project_id: "project-123",
+      event_schema_version: REVENUE_EVENT_SCHEMA_VERSION,
+    });
+  });
+
+  it("does not throw when window.dataLayer is not defined", () => {
+    delete (window as any).dataLayer;
+
+    const analytics: Analytics = new Analytics(apiHost, apiKey);
+
+    expect(() => {
+      analytics.capture("accounts/login");
+    }).not.toThrow();
+    expect(posthog.capture).toHaveBeenCalledWith("accounts/login", undefined);
+  });
+});

package/Tests/Utils/Monitor/MonitorMetricType.test.ts

@@ -398,3 +398,83 @@ describe("invariant: every probeable monitor type displays some metric", () => {
     expect(typesWithoutMetrics).toEqual([]);
   });
 });
+
+/*
+ * The null-returning variant exists because over-time evaluation asks "is
+ * there a series behind this CheckOn?" for every filter it sees. It used to
+ * ask by calling the throwing variant inside a try/catch that swallowed the
+ * error and quietly compared the instantaneous value instead - so "evaluate
+ * over time" was a silent no-op for every CheckOn missing from the map.
+ */
+describe("getMonitorMetricTypeByCheckOnOrNull", () => {
+  test("returns the same series as the throwing variant for mapped CheckOns", () => {
+    const mapped: Array<CheckOn> = [
+      CheckOn.ResponseTime,
+      CheckOn.ResponseStatusCode,
+      CheckOn.IsOnline,
+      CheckOn.CPUUsagePercent,
+      CheckOn.MemoryUsagePercent,
+      CheckOn.DiskUsagePercent,
+      CheckOn.PacketLossPercent,
+      CheckOn.Jitter,
+      CheckOn.PortDnsLookupTime,
+      CheckOn.PortTcpConnectTime,
+    ];
+
+    for (const checkOn of mapped) {
+      expect(
+        MonitorMetricTypeUtil.getMonitorMetricTypeByCheckOnOrNull(checkOn),
+      ).toBe(MonitorMetricTypeUtil.getMonitorMeticTypeByCheckOn(checkOn));
+    }
+  });
+
+  /*
+   * DNS, SNMP and External Status Page probes write into the shared online
+   * and response-time series like every other probe check, and the criteria
+   * UI advertises all six of these as over-time capable - but none of them
+   * had a mapping, so the window could never be read.
+   */
+  test("maps the DNS / SNMP / status page online checks onto the online series", () => {
+    for (const checkOn of [
+      CheckOn.DnsIsOnline,
+      CheckOn.SnmpIsOnline,
+      CheckOn.ExternalStatusPageIsOnline,
+    ]) {
+      expect(
+        MonitorMetricTypeUtil.getMonitorMetricTypeByCheckOnOrNull(checkOn),
+      ).toBe(MonitorMetricType.IsOnline);
+    }
+  });
+
+  test("maps their response time checks onto the response time series", () => {
+    for (const checkOn of [
+      CheckOn.DnsResponseTime,
+      CheckOn.SnmpResponseTime,
+      CheckOn.ExternalStatusPageResponseTime,
+    ]) {
+      expect(
+        MonitorMetricTypeUtil.getMonitorMetricTypeByCheckOnOrNull(checkOn),
+      ).toBe(MonitorMetricType.ResponseTime);
+    }
+  });
+
+  test("returns null instead of throwing for CheckOns no series records", () => {
+    for (const checkOn of [
+      CheckOn.ResponseBody,
+      CheckOn.ResponseHeader,
+      CheckOn.IsRequestTimeout,
+      CheckOn.JavaScriptExpression,
+      CheckOn.IncomingRequest,
+    ]) {
+      expect(
+        MonitorMetricTypeUtil.getMonitorMetricTypeByCheckOnOrNull(checkOn),
+      ).toBeNull();
+    }
+  });
+
+  test("the throwing variant still throws for those CheckOns", () => {
+    expect(() => {
+      MonitorMetricTypeUtil.getMonitorMeticTypeByCheckOn(CheckOn.ResponseBody);
+    }).toThrow();
+  });
+});