@oneuptime/common 12.0.31 → 12.0.33

package/Types/Telemetry/ErrorClass.ts

@@ -0,0 +1,274 @@
+/*
+ * The fault domain of a thrown value: whose problem is it?
+ *
+ * This is the canonical vocabulary for the whole platform. It was originally
+ * introduced as `ExceptionAIClassification` — an after-the-fact LLM verdict on
+ * an already-ingested exception group — but the same five values are what the
+ * emitting code needs in order to decide, at the moment an error is thrown,
+ * whether it is worth waking anyone up. That file now re-exports this one so
+ * there is exactly ONE answer to "what kind of failure is this" in the
+ * codebase, with several possible sources (declared > human > AI > default).
+ *
+ * - CodeFault: a defect in the monitored code — the only class the automatic
+ *   fix lane opens pull requests for. This is the BASE DEFAULT on purpose:
+ *   forgetting to classify an exception must leave it noisy, never silent.
+ * - UserError: expected consequence of invalid end-user input (bad
+ *   parameters, malformed values). The right change, if any, is earlier
+ *   validation and clearer error UX — routed to a human, never auto-fixed.
+ * - ExpectedDenial: an intentional check doing its job (auth failure,
+ *   plan/paywall denial, scanner/fuzzer probe tripping validation).
+ *   Never auto-fixed; optionally auto-archived.
+ * - Infrastructure: environmental conditions (timeouts, connection resets,
+ *   resource exhaustion) where a code "fix" is usually tuning — routed to a
+ *   human. NOTE: this stays an Issue. It is a real failure, just not one to
+ *   auto-fix.
+ * - Unknown: triage could not decide — treated conservatively (no automatic
+ *   fix, and still shown).
+ */
+enum ErrorClass {
+  CodeFault = "code-fault",
+  UserError = "user-error",
+  ExpectedDenial = "expected-denial",
+  Infrastructure = "infrastructure",
+  Unknown = "unknown",
+}
+
+/*
+ * The classes that do NOT warrant an Issue. Everything else — including
+ * Infrastructure and Unknown — stays loud.
+ *
+ * Exported as the single list so the emit path, the ingest path, the Issues
+ * list default scope and the AI detectors can never drift apart on which
+ * classes are suppressed.
+ */
+export const NON_ACTIONABLE_ERROR_CLASSES: ReadonlyArray<ErrorClass> = [
+  ErrorClass.UserError,
+  ErrorClass.ExpectedDenial,
+];
+
+export function isNonActionableErrorClass(value: unknown): boolean {
+  return NON_ACTIONABLE_ERROR_CLASSES.includes(value as ErrorClass);
+}
+
+/**
+ * Every value the enum can take, for validating strings that arrive from
+ * outside (an OTLP attribute, a database column written by an older release).
+ */
+export function toErrorClass(value: unknown): ErrorClass | null {
+  if (typeof value !== "string") {
+    return null;
+  }
+
+  const match: ErrorClass | undefined = Object.values(ErrorClass).find(
+    (candidate: ErrorClass) => {
+      return candidate === value;
+    },
+  );
+
+  return match ?? null;
+}
+
+/*
+ * `Symbol.for` rather than `Symbol()`: Common/ ships its own node_modules and
+ * is consumed by App/, Probe/, Runner/ and others, so this module can be
+ * instantiated more than once in a single process. A unique symbol would not
+ * match across those instances and a tag written by one copy would be
+ * invisible to another. The global symbol registry is keyed by string, so all
+ * copies agree.
+ */
+const ERROR_CLASS_SYMBOL: symbol = Symbol.for("oneuptime.error.class");
+const ERROR_CLASS_AUTHORITATIVE_SYMBOL: symbol = Symbol.for(
+  "oneuptime.error.class.authoritative",
+);
+const ERROR_REPORTED_SYMBOL: symbol = Symbol.for("oneuptime.error.reported");
+
+/**
+ * A fault domain plus how much to trust it.
+ *
+ * `authoritative: false` is a CLASS-LEVEL default — "BadDataException usually
+ * means the caller sent something wrong". It is a generalisation, so it is
+ * subject to the unit-of-work promotion: outside an HTTP request there is no
+ * caller, and the generalisation does not hold.
+ *
+ * `authoritative: true` is a SITE-LEVEL declaration — a developer looked at
+ * one specific throw or one specific log line and said what it is. That is a
+ * deliberate, reviewable judgment about a single place in the code, so it is
+ * never second-guessed. This is what lets a probe report "the endpoint we were
+ * asked to check is down" as a non-defect even though a probe check has no
+ * HTTP request around it.
+ */
+export interface DeclaredErrorClass {
+  errorClass: ErrorClass;
+  authoritative: boolean;
+}
+
+type Taggable = { [key: symbol]: unknown };
+
+function canTag(value: unknown): value is Taggable {
+  return (
+    value !== null && (typeof value === "object" || typeof value === "function")
+  );
+}
+
+/**
+ * Attach a fault domain to a thrown value.
+ *
+ * `enumerable: false` keeps it invisible to `JSON.stringify`,
+ * `Logger.redactBody` and `Telemetry.getExceptionAttributes`, so tagging can
+ * never change what a log line or a span attribute bag looks like.
+ *
+ * Never throws: this runs from the `Exception` constructor and from catch
+ * blocks, where a frozen object or a hostile Proxy must not take down the
+ * error path. Returns the value so it can be tagged inline.
+ */
+export function tagErrorClass<T>(
+  value: T,
+  errorClass: ErrorClass,
+  authoritative: boolean = false,
+): T {
+  if (!canTag(value)) {
+    return value;
+  }
+
+  try {
+    Object.defineProperty(value, ERROR_CLASS_SYMBOL, {
+      value: errorClass,
+      enumerable: false,
+      writable: true,
+      configurable: true,
+    });
+
+    if (authoritative) {
+      Object.defineProperty(value, ERROR_CLASS_AUTHORITATIVE_SYMBOL, {
+        value: true,
+        enumerable: false,
+        writable: true,
+        configurable: true,
+      });
+    }
+  } catch {
+    // Frozen / sealed / exotic object — the resolver falls back to CodeFault.
+  }
+
+  return value;
+}
+
+/**
+ * Declare the fault domain for ONE specific throw or log line, overriding the
+ * class-level default and exempting it from the unit-of-work promotion.
+ */
+export function tagErrorClassAuthoritative<T>(
+  value: T,
+  errorClass: ErrorClass,
+): T {
+  return tagErrorClass(value, errorClass, true);
+}
+
+/**
+ * Read the fault domain a thrown value declared for itself, or null when it
+ * declared none.
+ *
+ * A null return is meaningful and must stay distinct from
+ * `ErrorClass.Unknown`: "nobody predicted this" is the strongest possible
+ * signal that it is a bug, whereas Unknown means "we looked and could not
+ * tell". Callers turn null into CodeFault.
+ *
+ * Also duck-types off a plain `errorClass` property so an error crossing a
+ * process or module boundary (where the symbol is lost) can still declare
+ * itself.
+ */
+export function declaredErrorClass(value: unknown): DeclaredErrorClass | null {
+  if (!canTag(value)) {
+    return null;
+  }
+
+  try {
+    const authoritative: boolean =
+      value[ERROR_CLASS_AUTHORITATIVE_SYMBOL] === true;
+
+    const tagged: ErrorClass | null = toErrorClass(value[ERROR_CLASS_SYMBOL]);
+
+    if (tagged !== null) {
+      return { errorClass: tagged, authoritative: authoritative };
+    }
+
+    /*
+     * Duck-type off a plain property too, so an error that crossed a process
+     * or module boundary (where the symbol is lost) can still declare itself.
+     * A property survives serialization, so treat it as a deliberate
+     * declaration.
+     */
+    const ducked: ErrorClass | null = toErrorClass(
+      (value as { errorClass?: unknown }).errorClass,
+    );
+
+    if (ducked !== null) {
+      return { errorClass: ducked, authoritative: true };
+    }
+
+    return null;
+  } catch {
+    // Throwing getter on an exotic thrown value.
+    return null;
+  }
+}
+
+/**
+ * Mark a thrown value as already reported, returning whether it had ALREADY
+ * been marked.
+ *
+ * This is what stops one thrown error from filing N exception events as it
+ * propagates through N `@CaptureSpan` frames. The fingerprint hashes no spanId
+ * and no span name, so without this every frame's event lands in the same
+ * group and `occuranceCount` jumps by the depth of the call stack — measured
+ * at 3 for a create with a missing field and 6 for a permission-denied
+ * get-list.
+ *
+ * Untaggable values (a thrown string, a frozen object) always report `false`,
+ * i.e. they are reported every time. Over-reporting is the safe direction.
+ */
+export function markErrorReported(value: unknown): boolean {
+  if (!canTag(value)) {
+    return false;
+  }
+
+  try {
+    const alreadyReported: boolean = value[ERROR_REPORTED_SYMBOL] === true;
+
+    if (!alreadyReported) {
+      Object.defineProperty(value, ERROR_REPORTED_SYMBOL, {
+        value: true,
+        enumerable: false,
+        writable: true,
+        configurable: true,
+      });
+    }
+
+    return alreadyReported;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Test seam: forget that a value was reported. Only used by tests that reuse
+ * one error object across cases.
+ */
+export function clearErrorReported(value: unknown): void {
+  if (!canTag(value)) {
+    return;
+  }
+
+  try {
+    Object.defineProperty(value, ERROR_REPORTED_SYMBOL, {
+      value: false,
+      enumerable: false,
+      writable: true,
+      configurable: true,
+    });
+  } catch {
+    // Nothing to clear.
+  }
+}
+
+export default ErrorClass;

package/Types/Telemetry/UnitOfWork.ts

@@ -0,0 +1,59 @@
+/*
+ * What kind of work was in flight when something happened.
+ *
+ * This is the axis that makes class-based fault classification safe. The same
+ * exception class means different things depending on who asked for the work:
+ *
+ *   throw new BadDataException("Monitor type required to create monitor.")
+ *      -> inside an HTTP request: the caller sent a bad request. Not our bug.
+ *
+ *   throw new BadDataException("No job found with name: " + name)
+ *      -> inside a cron registration: an internal invariant we violated.
+ *         Very much our bug.
+ *
+ * They are indistinguishable at the throw site and perfectly distinguishable
+ * by unit of work, so ErrorClassResolver promotes user-error and
+ * expected-denial back to code-fault everywhere except an HTTP request.
+ *
+ * Seed this EXPLICITLY at every entry point. TelemetryContext.runWithContext
+ * inherits the enclosing scope's attributes, so an unset value would let a
+ * request's "http-request" marker leak into background work started from
+ * inside that request.
+ */
+export enum UnitOfWork {
+  HttpRequest = "http-request",
+  WorkerJob = "worker-job",
+  CronJob = "cron-job",
+  ProbeCheck = "probe-check",
+  Notification = "notification",
+  Startup = "startup",
+}
+
+/**
+ * Which deployment role produced this telemetry.
+ *
+ * Distinct from UnitOfWork, and distinct from `service.name`: the Helm chart
+ * runs the worker as a separate Deployment but from the same image and the
+ * same entrypoint (it only flips DISABLE_QUEUE_WORKERS), so worker pods report
+ * `service.name = "api"`. Until that changes — which re-keys every worker
+ * exception fingerprint and therefore needs its own release — this attribute
+ * is how "which component" becomes filterable.
+ */
+export enum TelemetryComponent {
+  Api = "api",
+  Worker = "worker",
+  Cron = "cron",
+  Probe = "probe",
+  Notification = "notification",
+}
+
+/**
+ * Ambient TelemetryContext / span attribute keys. String constants rather than
+ * inline literals so the emit path, drop filters, dashboards and tests cannot
+ * drift apart on spelling.
+ */
+export const UNIT_OF_WORK_ATTRIBUTE_KEY: string = "oneuptime.unit_of_work";
+export const COMPONENT_ATTRIBUTE_KEY: string = "oneuptime.component";
+
+/** Span/log attribute carrying the resolved fault domain. */
+export const ERROR_CLASS_ATTRIBUTE_KEY: string = "error.class";

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

@@ -63,6 +63,12 @@ export interface ComponentProps {
    * buckets calls back with the [start, end) of the selected time range.
    */
   onTimeRangeSelect?: ((startTime: Date, endTime: Date) => void) | undefined;
+  /*
+   * Double-click on the plot: undoes whatever drag-to-select produced.
+   * Supply it only when a reset is actually possible — see ChartLibrary
+   * onTimeRangeReset for why an idle handler costs click latency.
+   */
+  onTimeRangeReset?: (() => void) | undefined;
   // Plain click on a bucket — see ChartLibrary onBucketClick.
   onBucketClick?:
     | ((
@@ -241,6 +247,7 @@ const AreaChartElement: FunctionComponent<AreaInternalProps> = (
         }
         onExemplarClick={props.onExemplarClick}
         onTimeRangeSelect={props.onTimeRangeSelect}
+        onTimeRangeReset={props.onTimeRangeReset}
         onBucketClick={props.onBucketClick}
         ghostCategories={props.ghostSeriesNames}
         anomalyBandLowerKey={bandLower}

package/UI/Components/Charts/Bar/BarChart.tsx

@@ -58,6 +58,11 @@ export interface ComponentProps {
    * indexed by series position (index % length), matching the default palette.
    */
   colors?: Array<ChartColorValue> | undefined;
+  /*
+   * Double-click on the plot: undoes a board-wide zoom. Bar panels have no
+   * drag-to-select of their own but share the dashboard's time range.
+   */
+  onTimeRangeReset?: (() => void) | undefined;
 }
 
 export interface BarInternalProps extends ComponentProps {
@@ -152,6 +157,7 @@ const BarChartElement: FunctionComponent<BarInternalProps> = (
             ? formattedReferenceRegions
             : undefined
         }
+        onTimeRangeReset={props.onTimeRangeReset}
       />
       {hasNoData && <NoDataMessage />}
     </div>

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

@@ -147,9 +147,17 @@ const ChartGroup: FunctionComponent<ComponentProps> = (
       return <></>;
     }
 
+    /*
+     * The way back out is only worth naming while there is something to
+     * reset — the host supplies onTimeRangeReset exactly then.
+     */
+    const canReset: boolean = Boolean(
+      (chart.props as LineChartProps | AreaChartProps).onTimeRangeReset,
+    );
+
     return (
       <span className="ml-auto shrink-0 whitespace-nowrap text-[10px] text-gray-400">
-        Drag to zoom
+        {canReset ? "Drag to zoom · double-click to reset" : "Drag to zoom"}
       </span>
     );
   };

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

@@ -40,6 +40,7 @@ import useChartAnnotations, {
   UseChartAnnotationsResult,
 } from "../Annotations/UseChartAnnotations";
 import { cx } from "../Utils/Cx";
+import { DOUBLE_CLICK_DISAMBIGUATION_MS } from "../Utils/DoubleClick";
 import { getYAxisDomain } from "../Utils/GetYAxisDomain";
 import { hasOnlyOneValueForKey } from "../Utils/HasOnlyOneValueForKey";
 import {
@@ -625,6 +626,15 @@ interface AreaChartProps extends React.HTMLAttributes<HTMLDivElement> {
   formattedExemplarPoints?: Array<FormattedExemplarPoint> | undefined;
   onExemplarClick?: ((exemplar: ExemplarPoint) => void) | undefined;
   onTimeRangeSelect?: ((startTime: Date, endTime: Date) => void) | undefined;
+  /**
+   * Double-click on the plot surface: the counterpart to drag-to-select,
+   * for undoing the zoom it produced. Supplying it makes single clicks
+   * wait DOUBLE_CLICK_DISAMBIGUATION_MS before they act, so a double-click
+   * cannot also fire the bucket-click path twice on its way past — hosts
+   * that have nothing to reset should leave it undefined and keep clicks
+   * instant.
+   */
+  onTimeRangeReset?: (() => void) | undefined;
   /**
    * Plain click on a time bucket (the plot background — dot/legend clicks
    * and drag-selections never reach this). [bucketStart, bucketEnd) uses
@@ -693,6 +703,7 @@ const AreaChart: React.ForwardRefExoticComponent<
       formattedTimeReferenceLines,
       formattedReferenceRegions,
       onTimeRangeSelect,
+      onTimeRangeReset,
       onBucketClick,
       ghostCategories,
       ...other
@@ -723,9 +734,26 @@ const AreaChart: React.ForwardRefExoticComponent<
       React.useRef<number | null>(null);
     const suppressNextClickRef: React.MutableRefObject<boolean> =
       React.useRef<boolean>(false);
+    const hasOnTimeRangeReset: boolean = Boolean(onTimeRangeReset);
+    /*
+     * A pending single-click, held open long enough for a second click to
+     * cancel it. Only armed when onTimeRangeReset is supplied.
+     */
+    const pendingClickTimeoutRef: React.MutableRefObject<ReturnType<
+      typeof setTimeout
+    > | null> = React.useRef<ReturnType<typeof setTimeout> | null>(null);
     const categoryColors: Map<string, ChartColorValue> =
       constructCategoryColors(categories, colors);
 
+    React.useEffect(() => {
+      return () => {
+        if (pendingClickTimeoutRef.current !== null) {
+          clearTimeout(pendingClickTimeoutRef.current);
+          pendingClickTimeoutRef.current = null;
+        }
+      };
+    }, []);
+
     /*
      * Annotations are drawn onto the categorical axis, so the layer needs
      * the same x values recharts is drawing — not the source dates.
@@ -971,6 +999,51 @@ const AreaChart: React.ForwardRefExoticComponent<
       onTimeRangeSelect(startDate, endDate);
     }
 
+    /*
+     * The plain-click path, split out so it can either run inline (no
+     * reset handler) or be deferred behind the double-click window.
+     */
+    function handleChartClick(chartState: RangeSelectionChartState): void {
+      /*
+       * A click while a legend/dot selection is active keeps its
+       * long-standing meaning — clear the selection — and never
+       * also pins a bucket.
+       */
+      if (hasOnValueChange && (activeLegend || activeDot)) {
+        setActiveDot(undefined);
+        setActiveLegend(undefined);
+        onValueChange?.(null);
+        return;
+      }
+      if (!onBucketClick) {
+        return;
+      }
+      const rowIndex: number | null = getRowIndexFromChartState(chartState);
+      if (rowIndex === null) {
+        return;
+      }
+      const bucketStart: Date | null = getBucketDateAtIndex(rowIndex);
+      if (!bucketStart) {
+        return;
+      }
+      /*
+       * Cover the full bucket: width from adjacent row dates, the
+       * same derivation drag-to-select uses.
+       */
+      const adjacentBucketDate: Date | null =
+        rowIndex > 0
+          ? getBucketDateAtIndex(rowIndex - 1)
+          : getBucketDateAtIndex(rowIndex + 1);
+      const clickedBucketWidthInMs: number = adjacentBucketDate
+        ? Math.abs(bucketStart.getTime() - adjacentBucketDate.getTime())
+        : 0;
+      onBucketClick(
+        bucketStart,
+        new Date(bucketStart.getTime() + clickedBucketWidthInMs),
+        (data[rowIndex] || {}) as Record<string, number | string>,
+      );
+    }
+
     return (
       <div
         ref={ref}
@@ -1009,46 +1082,35 @@ const AreaChart: React.ForwardRefExoticComponent<
                 if (suppressNextClickRef.current) {
                   return;
                 }
-                /*
-                 * A click while a legend/dot selection is active keeps its
-                 * long-standing meaning — clear the selection — and never
-                 * also pins a bucket.
-                 */
-                if (hasOnValueChange && (activeLegend || activeDot)) {
-                  setActiveDot(undefined);
-                  setActiveLegend(undefined);
-                  onValueChange?.(null);
-                  return;
-                }
-                if (!onBucketClick) {
-                  return;
-                }
-                const rowIndex: number | null =
-                  getRowIndexFromChartState(chartState);
-                if (rowIndex === null) {
-                  return;
-                }
-                const bucketStart: Date | null = getBucketDateAtIndex(rowIndex);
-                if (!bucketStart) {
+                if (!hasOnTimeRangeReset) {
+                  handleChartClick(chartState);
                   return;
                 }
                 /*
-                 * Cover the full bucket: width from adjacent row dates, the
-                 * same derivation drag-to-select uses.
+                 * Reset is on, so hold the click open: both clicks of a
+                 * double-click arrive before dblclick does, and neither
+                 * may pin a bucket. The second click re-arms the timer,
+                 * dblclick clears it.
                  */
-                const adjacentDate: Date | null =
-                  rowIndex > 0
-                    ? getBucketDateAtIndex(rowIndex - 1)
-                    : getBucketDateAtIndex(rowIndex + 1);
-                const bucketWidthInMs: number = adjacentDate
-                  ? Math.abs(bucketStart.getTime() - adjacentDate.getTime())
-                  : 0;
-                onBucketClick(
-                  bucketStart,
-                  new Date(bucketStart.getTime() + bucketWidthInMs),
-                  (data[rowIndex] || {}) as Record<string, number | string>,
-                );
+                if (pendingClickTimeoutRef.current !== null) {
+                  clearTimeout(pendingClickTimeoutRef.current);
+                }
+                pendingClickTimeoutRef.current = setTimeout(() => {
+                  pendingClickTimeoutRef.current = null;
+                  handleChartClick(chartState);
+                }, DOUBLE_CLICK_DISAMBIGUATION_MS);
               }}
+              {...(hasOnTimeRangeReset
+                ? {
+                    onDoubleClick: () => {
+                      if (pendingClickTimeoutRef.current !== null) {
+                        clearTimeout(pendingClickTimeoutRef.current);
+                        pendingClickTimeoutRef.current = null;
+                      }
+                      onTimeRangeReset?.();
+                    },
+                  }
+                : {})}
               margin={{
                 bottom: (xAxisLabel
                   ? 40

package/UI/Components/Charts/ChartLibrary/BarChart/BarChart.tsx

@@ -692,6 +692,12 @@ interface BarChartProps extends React.HTMLAttributes<HTMLDivElement> {
   referenceLines?: Array<ChartReferenceLineProps> | undefined;
   formattedTimeReferenceLines?: Array<FormattedTimeReferenceLine> | undefined;
   formattedReferenceRegions?: Array<FormattedReferenceRegion> | undefined;
+  /**
+   * Double-click on the plot surface. Bar charts have no drag-to-select of
+   * their own, but they sit on the same dashboards as line/area panels and
+   * must offer the same way out of a board-wide zoom.
+   */
+  onTimeRangeReset?: (() => void) | undefined;
 }
 
 const BarChart: React.ForwardRefExoticComponent<
@@ -735,6 +741,7 @@ const BarChart: React.ForwardRefExoticComponent<
       customTooltip,
       formattedTimeReferenceLines,
       formattedReferenceRegions,
+      onTimeRangeReset,
       ...other
     } = props;
     const CustomTooltip: React.ComponentType<any> | undefined = customTooltip;
@@ -877,6 +884,13 @@ const BarChart: React.ForwardRefExoticComponent<
                     onClick: handleChartClick,
                   }
                 : {})}
+              {...(onTimeRangeReset
+                ? {
+                    onDoubleClick: () => {
+                      onTimeRangeReset();
+                    },
+                  }
+                : {})}
               margin={{
                 bottom: xAxisLabel ? 40 : showXAxis ? 24 : 8,
                 left: yAxisLabel ? 20 : 0,