@oneuptime/common 12.0.20 → 12.0.21

package/Tests/UI/Components/Charts/TooltipEntries.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "@jest/globals";
 import {
   DEFAULT_TOOLTIP_MAX_ENTRIES,
+  PREVIOUS_PERIOD_SERIES_SUFFIX,
   PreparedTooltipEntries,
   SortableTooltipItem,
   prepareTooltipEntries,
@@ -53,24 +54,24 @@ describe("prepareTooltipEntries", () => {
     expect(categories(prepared)).toEqual(["cpu1", "cpu2", "cpu10"]);
   });
 
-  test("sorts non-finite values last without dropping them", () => {
+  test("sorts non-finite values last and drops band tuples entirely", () => {
     const prepared: PreparedTooltipEntries<TestItem> = prepareTooltipEntries([
       item("nan-series", NaN),
       item("real-low", 1),
       item("infinite", Infinity),
       item("real-high", 7),
-      // The anomaly band's dataKey yields a [low, high] tuple at runtime.
+      /*
+       * The anomaly band's dataKey yields a [low, high] tuple at runtime
+       * — a shaded region, not a series, so it must not render as a row
+       * nor count toward the overflow footer.
+       */
       item("band", [2, 9] as unknown as number),
     ]);
 
     expect(categories(prepared).slice(0, 2)).toEqual(["real-high", "real-low"]);
     // Non-finite tail keeps natural name order among itself.
-    expect(categories(prepared).slice(2)).toEqual([
-      "band",
-      "infinite",
-      "nan-series",
-    ]);
-    expect(prepared.totalCount).toBe(5);
+    expect(categories(prepared).slice(2)).toEqual(["infinite", "nan-series"]);
+    expect(prepared.totalCount).toBe(4);
   });
 
   test('filters out type "none" entries (hidden click-target lines, band fills)', () => {
@@ -143,6 +144,41 @@ describe("prepareTooltipEntries", () => {
     }
   });
 
+  test("previous-period ghosts sort after every live series, whatever their value", () => {
+    const prepared: PreparedTooltipEntries<TestItem> = prepareTooltipEntries([
+      item(`host-a${PREVIOUS_PERIOD_SERIES_SUFFIX}`, 999),
+      item("host-a", 10),
+      item("host-b", 50),
+      item(`host-b${PREVIOUS_PERIOD_SERIES_SUFFIX}`, 60),
+    ]);
+
+    expect(categories(prepared)).toEqual([
+      "host-b",
+      "host-a",
+      // Ghost tier keeps its own value ordering.
+      `host-a${PREVIOUS_PERIOD_SERIES_SUFFIX}`,
+      `host-b${PREVIOUS_PERIOD_SERIES_SUFFIX}`,
+    ]);
+  });
+
+  test("ghosts never displace live readings under the cap", () => {
+    const payload: Array<TestItem> = [];
+    for (let index: number = 0; index < DEFAULT_TOOLTIP_MAX_ENTRIES; index++) {
+      payload.push(item(`live-${index}`, index));
+      payload.push(item(`live-${index}${PREVIOUS_PERIOD_SERIES_SUFFIX}`, 1e6));
+    }
+
+    const prepared: PreparedTooltipEntries<TestItem> =
+      prepareTooltipEntries(payload);
+
+    expect(
+      prepared.entries.every((entry: TestItem) => {
+        return !entry.category.endsWith(PREVIOUS_PERIOD_SERIES_SUFFIX);
+      }),
+    ).toBe(true);
+    expect(prepared.overflowCount).toBe(DEFAULT_TOOLTIP_MAX_ENTRIES);
+  });
+
   test("does not mutate the input payload", () => {
     const payload: Array<TestItem> = [item("low", 1), item("high", 2)];
     prepareTooltipEntries(payload);

package/Tests/Utils/Telemetry/CrossSignalScope.test.ts

@@ -597,9 +597,20 @@ describe("toMetricsExplorerQueryParams", () => {
     });
 
     test("reports the signal-specific fields the metric grammar cannot express", () => {
+      const result: CrossSignalQueryParams = toMetricsExplorerQueryParams(
+        fullScope(),
+        "container.cpu.time",
+      );
+
+      /*
+       * serviceIds now CARRY: they ride the explorer's one-shot
+       * `services` param (resolved to resource.service.name filters on
+       * load) instead of being reported dropped.
+       */
+      expect(result.dropped).toEqual(["traceIds", "spanIds", "severityTexts"]);
       expect(
-        toMetricsExplorerQueryParams(fullScope(), "container.cpu.time").dropped,
-      ).toEqual(["serviceIds", "traceIds", "spanIds", "severityTexts"]);
+        JSON.parse(result.params["services"] as string).length,
+      ).toBeGreaterThan(0);
     });
   });
 

package/Types/AnalyticsDatabase/AnalyticsTableName.ts

@@ -7,6 +7,13 @@ enum AnalyticsTableName {
    * attributes with a keys sidecar for arbitrary-field filtering.
    */
   SecurityEvent = "SecurityEventItemV1",
+  /*
+   * Deploy/config-change markers posted by CI/CD, rendered as dashed
+   * vertical lines on metric charts. Peer of LogItemV3 in layout (tenant
+   * projectId, per-row retentionDate TTL, attributes Map + keys sidecar)
+   * but tiny in volume.
+   */
+  ChangeEvent = "ChangeEventV1",
   Metric = "MetricItemV3",
   ExceptionInstance = "ExceptionItemV3",
   Span = "SpanItemV3",

package/Types/Marketing/Attribution.ts

@@ -3,19 +3,14 @@
  * writes it.
  *
  * Attribution starts in the browser (Home/Views/head-basic.ejs stores it in
- * localStorage) and reaches the server through two unrelated doors:
+ * localStorage) and reaches the server through the signup form
+ * (App/FeatureSet/Accounts/src/Pages/Register.tsx), which posts it onto the
+ * User record.
  *
- *   - the signup form (App/FeatureSet/Accounts/src/Pages/Register.tsx), which
- *     posts it onto the User record;
- *   - the Cal.com booking webhook (App/API/CalWebhook.ts), which reads it back
- *     out of the booking metadata the embed carried. Every page that books —
- *     /enterprise/demo, /support, /enterprise/self-hosted — goes through it.
- *
- * Both doors are reachable by an unauthenticated caller, so both must whitelist
- * and length-bound what they accept. Keeping the key lists here rather than in
- * each door means a key added for the browser cannot be silently dropped by one
- * of the readers — which is exactly what happened to UTM parameters on the Cal
- * path, where the webhook parsed click IDs the embed never sent.
+ * That door is reachable by an unauthenticated caller, so it must whitelist and
+ * length-bound what it accepts. Keeping the key lists here rather than in the
+ * door itself means a key added for the browser cannot be silently dropped on
+ * arrival.
  */
 
 // Ad-platform click identifiers, in the spelling each platform uses on the URL.
@@ -31,9 +26,8 @@ export const AdClickIdKeys: Array<string> = [
 ];
 
 /*
- * UTM parameters travel as snake_case on a URL and in Cal booking metadata,
- * and as camelCase once they are columns on User/Project/MarketingConversion.
- * Both spellings are accepted on the way in — Cal booking questions and hand
+ * UTM parameters travel as snake_case on a URL and as camelCase once they are
+ * columns on User/Project. Both spellings are accepted on the way in — hand
  * written links produce either — and only the camelCase form is stored.
  */
 export const UtmWireKeyToPropertyKey: Record<string, string> = {

package/Types/Marketing/MarketingEvent.ts

@@ -13,7 +13,7 @@ import { JSONObject } from "../JSON";
  *
  *   - DEDUPLICATION. `eventId` is stable for a given real-world occurrence, so
  *     a redelivery carries the id the first attempt did. Retries are expected
- *     (the queue retries, and Cal retries into us), so a receiver that keys on
+ *     (the delivery queue retries), so a receiver that keys on
  *     anything else will double-count.
  *   - ORDERING. Events are delivered per-occurrence with no sequence number.
  *     A signup and a plan change seconds apart may arrive either way round;
@@ -26,7 +26,6 @@ import { JSONObject } from "../JSON";
  */
 export enum MarketingEventType {
   SignUp = "sign_up",
-  MeetingBooked = "meeting_booked",
   /*
    * A project's first paid subscription, created together with the project.
    *
@@ -45,53 +44,19 @@ export enum MarketingEventType {
    * whose email is typed in by a human rather than captured from a session —
    * which is exactly what makes it joinable: set EnterpriseLicense.email to
    * the address the customer booked with and this event shares an identity
-   * with the meeting_booked that preceded it, months earlier.
+   * with whatever else that address has done, months earlier.
    */
   EnterpriseLicenseIssued = "enterprise_license_issued",
 }
 
-/*
- * Which conversation a booked meeting actually is.
- *
- * All three Cal embeds book the same event type (oneuptimehq/demo), so without
- * this the webhook cannot tell a free user's support call from a net-new
- * enterprise demo — they arrive as one undifferentiated `meeting_booked`, and
- * anything bidding on or reporting against that count values them identically.
- *
- * The browser event has carried this since the embeds were instrumented; the
- * webhook did not, which meant the authoritative record was the one that could
- * not make the distinction.
- *
- * `Unknown` is a real state, not a failure: a booking made through a Cal link
- * that was not one of the instrumented embeds genuinely has no kind, and is
- * still a booking worth emitting.
- */
-export enum MeetingBookingKind {
-  EnterpriseDemo = "enterprise_demo",
-  SupportCall = "support_call",
-  ArchitectureAssessment = "architecture_assessment",
-  Unknown = "unknown",
-}
-
-/*
- * The Cal booking-metadata key the embeds write and the webhook reads. Shared
- * so a rename cannot land on one side only - the failure mode there is silent,
- * because a booking with no recognised kind still succeeds.
- */
-export const BOOKING_KIND_METADATA_KEY: string = "ou_booking_kind";
-
-export const MeetingBookingKinds: Array<string> =
-  Object.values(MeetingBookingKind);
-
 export const MARKETING_EVENT_SCHEMA_VERSION: number = 1;
 
 /*
  * The campaign the converting visitor carried.
  *
- * Copied from the User or Project row for a signup or a plan change, and read
- * out of Cal booking metadata for a booked meeting. Every field is optional:
- * a conversion with no attribution at all is still a conversion, and is still
- * emitted.
+ * Copied from the User or Project row the conversion happened on. Every field
+ * is optional: a conversion with no attribution at all is still a conversion,
+ * and is still emitted.
  */
 export interface MarketingEventAttribution extends JSONObject {
   utmSource?: string | undefined;
@@ -110,17 +75,16 @@ export interface MarketingEvent extends JSONObject {
    * Stable per real-world occurrence, and the receiver's deduplication key:
    *
    *   sign_up:{userId}
-   *   meeting_booked:{calBookingUid}
    *   subscription_started:{projectId}
    *   subscription_upgraded:{projectId}:{occurredAt}
    *   subscription_downgraded:{projectId}:{occurredAt}
    *   enterprise_license_issued:{enterpriseLicenseId}
    *
-   * Four of these are naturally unique — a user signs up once, a booking has
-   * one uid, a project has one first subscription, a licence row is issued
-   * once — so Cal retrying a delivery or the queue retrying a job cannot
-   * produce a second conversion. A plan change can legitimately recur for one
-   * project, so its id carries the instant it happened.
+   * Three of these are naturally unique — a user signs up once, a project has
+   * one first subscription, a licence row is issued once — so the queue
+   * retrying a job cannot produce a second conversion. A plan change can
+   * legitimately recur for one project, so its id carries the instant it
+   * happened.
    */
   eventId: string;
   eventType: MarketingEventType;

package/UI/Components/Charts/Area/AreaChart.tsx

@@ -63,6 +63,19 @@ export interface ComponentProps {
    * buckets calls back with the [start, end) of the selected time range.
    */
   onTimeRangeSelect?: ((startTime: Date, endTime: Date) => void) | undefined;
+  // Plain click on a bucket — see ChartLibrary onBucketClick.
+  onBucketClick?:
+    | ((
+        bucketStart: Date,
+        bucketEnd: Date,
+        valuesAtBucket: Record<string, number | string>,
+      ) => void)
+    | undefined;
+  /*
+   * Series rendered as compare-to-previous-period ghosts (dashed, faded,
+   * dotless). Names must exist in `data`.
+   */
+  ghostSeriesNames?: Array<string> | undefined;
   showLegend?: boolean | undefined;
   /**
    * Render a shaded "expected range" band underneath the plotted lines.
@@ -228,6 +241,8 @@ const AreaChartElement: FunctionComponent<AreaInternalProps> = (
         }
         onExemplarClick={props.onExemplarClick}
         onTimeRangeSelect={props.onTimeRangeSelect}
+        onBucketClick={props.onBucketClick}
+        ghostCategories={props.ghostSeriesNames}
         anomalyBandLowerKey={bandLower}
         anomalyBandUpperKey={bandUpper}
       />

package/UI/Components/Charts/ChartGroup/ChartGroup.tsx

@@ -57,12 +57,27 @@ export interface ComponentProps {
   charts: Array<Chart>;
   hideCard?: boolean | undefined;
   chartCssClass?: string | undefined;
+  /**
+   * Share one crosshair-sync channel across SEVERAL ChartGroup instances
+   * (e.g. every metric widget on one dashboard passes the dashboard id,
+   * so hovering an instant on one widget highlights it on all of them).
+   * Absent → this group syncs only within itself.
+   */
+  syncId?: string | undefined;
 }
 
 const ChartGroup: FunctionComponent<ComponentProps> = (
   props: ComponentProps,
 ): ReactElement => {
-  const syncId: string = Text.generateRandomText(10);
+  /*
+   * Stable per-mount fallback: a plain const regenerated the id on every
+   * render, which forced recharts to tear down and re-subscribe its sync
+   * listeners on each parent re-render (auto-refresh ticks included).
+   */
+  const [fallbackSyncId] = useState<string>(() => {
+    return Text.generateRandomText(10);
+  });
+  const syncId: string = props.syncId || fallbackSyncId;
   const [metricInfoModalChart, setMetricInfoModalChart] =
     useState<ChartMetricInfo | null>(null);