@oneuptime/common 10.5.8 → 10.5.17

package/Server/Utils/Telemetry/TelemetryContext.ts

@@ -0,0 +1,190 @@
+import { DisableTelemetry } from "../../EnvironmentConfig";
+import { AsyncLocalStorage } from "async_hooks";
+
+export type TelemetryContextAttributeValue =
+  | string
+  | number
+  | boolean
+  | undefined;
+
+/**
+ * Canonical set of tenant/business attributes we propagate across a unit of
+ * work (an HTTP request, a worker job, a probe check, a cron run). The open
+ * index signature allows additional ad-hoc keys, but prefer the named ones so
+ * dashboards and queries stay consistent.
+ */
+export interface TelemetryContextAttributes {
+  userId?: string | undefined;
+  projectId?: string | undefined;
+  requestId?: string | undefined;
+  incidentId?: string | undefined;
+  alertId?: string | undefined;
+  monitorId?: string | undefined;
+  statusPageId?: string | undefined;
+  scheduledMaintenanceId?: string | undefined;
+  onCallDutyPolicyId?: string | undefined;
+  onCallDutyPolicyScheduleId?: string | undefined;
+  incidentEpisodeId?: string | undefined;
+  alertEpisodeId?: string | undefined;
+  workspaceType?: string | undefined;
+  channelId?: string | undefined;
+  [key: string]: TelemetryContextAttributeValue;
+}
+
+interface TelemetryContextStore {
+  attributes: Record<string, string | number | boolean>;
+}
+
+/**
+ * Ambient, mutable telemetry context backed by AsyncLocalStorage.
+ *
+ * Why this exists: OpenTelemetry span attributes do NOT propagate from a
+ * parent span to its children, and OneUptime sets tenant context (projectId,
+ * userId, ...) deep in middleware while the spans that matter are created much
+ * further down the call stack. Rather than thread attributes through every
+ * function or tag ~1958 `@CaptureSpan` call sites by hand, we keep a small
+ * mutable attribute bag scoped to the current unit of work. `ContextSpanProcessor`
+ * stamps it onto every span at creation, and `Logger` merges it into every log
+ * record — so context flows everywhere automatically.
+ *
+ * Seed a scope at each entry point with `runWithContext`, then enrich it as
+ * more identifiers become known with `setAttributes`.
+ */
+export default class TelemetryContext {
+  private static storage: AsyncLocalStorage<TelemetryContextStore> =
+    new AsyncLocalStorage<TelemetryContextStore>();
+
+  /**
+   * Identifier keys we look for when seeding context from an arbitrary payload
+   * (see {@link pickKnownAttributes}).
+   */
+  private static readonly KNOWN_ID_KEYS: Array<string> = [
+    "projectId",
+    "userId",
+    "monitorId",
+    "incidentId",
+    "alertId",
+    "statusPageId",
+    "scheduledMaintenanceId",
+    "onCallDutyPolicyId",
+    "onCallDutyPolicyScheduleId",
+    "incidentEpisodeId",
+    "alertEpisodeId",
+    "workspaceType",
+    "channelId",
+    "requestId",
+  ];
+
+  /**
+   * Run `fn` within a fresh telemetry-context scope seeded with `attributes`.
+   * Any attributes from an enclosing scope are inherited so nested units of
+   * work (e.g. a job spawned while handling a request) keep their context.
+   */
+  public static runWithContext<T>(
+    attributes: TelemetryContextAttributes,
+    fn: () => T,
+  ): T {
+    if (DisableTelemetry) {
+      return fn();
+    }
+
+    const inherited: Record<string, string | number | boolean> =
+      this.getAttributes();
+
+    const store: TelemetryContextStore = {
+      attributes: { ...inherited },
+    };
+
+    this.mergeInto(store.attributes, attributes);
+
+    return this.storage.run(store, fn);
+  }
+
+  /**
+   * Merge `attributes` into the current scope. No-op when there is no active
+   * scope (e.g. code running outside any seeded entry point) or telemetry is
+   * disabled, so it is always safe to call.
+   */
+  public static setAttributes(attributes: TelemetryContextAttributes): void {
+    if (DisableTelemetry) {
+      return;
+    }
+
+    const store: TelemetryContextStore | undefined = this.storage.getStore();
+
+    if (!store) {
+      return;
+    }
+
+    this.mergeInto(store.attributes, attributes);
+  }
+
+  /**
+   * Read the attributes for the current scope. Returns an empty object when
+   * there is no active scope. The returned object is the live store — treat it
+   * as read-only (consumers copy it before mutating).
+   */
+  public static getAttributes(): Record<string, string | number | boolean> {
+    const store: TelemetryContextStore | undefined = this.storage.getStore();
+
+    if (!store) {
+      return {};
+    }
+
+    return store.attributes;
+  }
+
+  /**
+   * Best-effort extraction of known tenant/business identifiers from an
+   * arbitrary object (e.g. a queue job's `data` payload), so worker jobs can
+   * seed context without every job knowing about telemetry. Values are coerced
+   * to strings; unknown/empty values are skipped.
+   */
+  public static pickKnownAttributes(data: unknown): TelemetryContextAttributes {
+    const attributes: TelemetryContextAttributes = {};
+
+    if (!data || typeof data !== "object") {
+      return attributes;
+    }
+
+    const record: Record<string, unknown> = data as Record<string, unknown>;
+
+    for (const key of this.KNOWN_ID_KEYS) {
+      const value: unknown = record[key];
+
+      if (value === undefined || value === null) {
+        continue;
+      }
+
+      if (
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean"
+      ) {
+        attributes[key] = value;
+        continue;
+      }
+
+      // ObjectID-like values expose a meaningful toString().
+      const asString: string = String(value);
+      if (asString && asString !== "[object Object]") {
+        attributes[key] = asString;
+      }
+    }
+
+    return attributes;
+  }
+
+  private static mergeInto(
+    target: Record<string, string | number | boolean>,
+    attributes: TelemetryContextAttributes,
+  ): void {
+    for (const key in attributes) {
+      const value: TelemetryContextAttributeValue = attributes[key];
+
+      if (value !== undefined && value !== null) {
+        target[key] = value;
+      }
+    }
+  }
+}

package/Server/Utils/Telemetry.ts

@@ -39,7 +39,11 @@ import {
 } from "@opentelemetry/sdk-metrics";
 import type { PushMetricExporter } from "@opentelemetry/sdk-metrics/build/src/export/MetricExporter";
 import * as opentelemetry from "@opentelemetry/sdk-node";
-import { SpanExporter } from "@opentelemetry/sdk-trace-base";
+import {
+  BatchSpanProcessor,
+  SpanExporter,
+  SpanProcessor,
+} from "@opentelemetry/sdk-trace-base";
 import {
   ATTR_SERVICE_NAME,
   ATTR_SERVICE_VERSION,
@@ -48,6 +52,7 @@ import URL from "../../Types/API/URL";
 import Dictionary from "../../Types/Dictionary";
 import { AppVersion, Env, DisableTelemetry } from "../EnvironmentConfig";
 import logger from "./Logger";
+import ContextSpanProcessor from "./Telemetry/ContextSpanProcessor";
 import RuntimeMetrics from "./Telemetry/RuntimeMetrics";
 
 type ResourceWithRawAttributes = LogsResource & {
@@ -268,10 +273,21 @@ export default class Telemetry {
           autoDetectResources: true,
         };
 
+      /*
+       * Always run the ContextSpanProcessor so the ambient TelemetryContext
+       * attributes (projectId, userId, monitorId, incidentId, requestId, ...)
+       * are stamped onto every span at creation. The BatchSpanProcessor that
+       * actually exports spans is added after it, and only when an exporter is
+       * configured. (traceExporter is deprecated in favour of spanProcessors.)
+       */
+      const spanProcessors: Array<SpanProcessor> = [new ContextSpanProcessor()];
+
       if (traceExporter) {
-        nodeSdkConfiguration.traceExporter = traceExporter;
+        spanProcessors.push(new BatchSpanProcessor(traceExporter));
       }
 
+      nodeSdkConfiguration.spanProcessors = spanProcessors;
+
       /*
        * We will skip this becasue we're attachng this metric reader to the meter provider later.
        * if (this.metricReader) {

package/Types/Database/AccessControl/OwnedThrough.ts

@@ -2,11 +2,39 @@ import GenericFunction from "../../GenericFunction";
 
 export interface OwnedThroughMetadata {
   fkColumn: string;
-  parentModel: GenericFunction;
+  /*
+   * The parent resource type(s) whose ownership grants access to this
+   * model's rows. Usually one (e.g. Monitor), but a polymorphic FK can
+   * inherit ownership from several resource types — e.g. a telemetry
+   * row's serviceId may reference a Service, Host, DockerHost or
+   * KubernetesCluster, so Owned scope unions the owned ids across all of
+   * them.
+   */
+  parentModels: Array<GenericFunction>;
+  /*
+   * When true, rows whose fkColumn equals the tenant (project) id itself
+   * are also visible under Owned scope. Telemetry with no owning resource
+   * (the unattributed "Unknown" bucket) is tagged with the projectId in
+   * place of a resource id; it belongs to the project, not any single
+   * owner, so every in-project user with the table permission may see it.
+   */
+  includeProjectScope: boolean;
 }
 
-export default (fkColumn: string, parentModel: GenericFunction) => {
+export interface OwnedThroughOptions {
+  includeProjectScope?: boolean;
+}
+
+export default (
+  fkColumn: string,
+  parentModel: GenericFunction | Array<GenericFunction>,
+  options?: OwnedThroughOptions,
+) => {
   return (ctr: GenericFunction) => {
-    ctr.prototype.ownedThrough = { fkColumn, parentModel };
+    ctr.prototype.ownedThrough = {
+      fkColumn,
+      parentModels: Array.isArray(parentModel) ? parentModel : [parentModel],
+      includeProjectScope: options?.includeProjectScope ?? false,
+    };
   };
 };

package/Types/SmsStatus.ts

@@ -1,7 +1,23 @@
 enum SmsStatus {
+  /*
+   * Legacy / synchronous statuses.
+   * "Success" was historically set the moment Twilio accepted the message (before
+   * delivery tracking existed). It is kept for backward compatibility with rows
+   * written before delivery receipts were introduced.
+   */
   Success = "Success",
   Error = "Error",
   LowBalance = "Low Balance",
+
+  /*
+   * Delivery lifecycle statuses, driven by Twilio status callbacks.
+   * Sending -> Sent -> Delivered (terminal) | Undelivered (terminal) | Failed (terminal)
+   */
+  Sending = "Sending", // queued / accepted / sending — handed to Twilio, not yet at carrier
+  Sent = "Sent", // accepted by the carrier, awaiting a delivery receipt
+  Delivered = "Delivered", // carrier confirmed delivery to the handset
+  Undelivered = "Undelivered", // carrier could not deliver (e.g. filtered, unreachable)
+  Failed = "Failed", // Twilio could not send the message
 }
 
 export default SmsStatus;

package/Types/Telemetry/ServiceType.ts

@@ -14,6 +14,16 @@ enum ServiceType {
   Host = "Host",
   DockerHost = "DockerHost",
   KubernetesCluster = "KubernetesCluster",
+  /*
+   * Telemetry that arrived without an OTel service.name and with no
+   * host / docker / k8s resource signal. Instead of synthesising a
+   * placeholder "Unknown Service" Postgres row (which collected every
+   * oneuptime.label.* attribute from unrelated sources), the row's
+   * `serviceId` slot holds the projectId and no Service row is created.
+   * The read side renders these under a synthetic "Unknown Service"
+   * bucket.
+   */
+  Unknown = "Unknown",
 }
 
 export default ServiceType;

package/UI/Components/LogsViewer/LogsViewer.tsx

@@ -60,6 +60,8 @@ import { queryStringToFilter } from "../../../Types/Log/LogQueryToFilter";
 import RangeStartAndEndDateTime from "../../../Types/Time/RangeStartAndEndDateTime";
 import TimeRange from "../../../Types/Time/TimeRange";
 import { exportLogs, LogExportFormat } from "../../Utils/LogExport";
+import ProjectUtil from "../../Utils/Project";
+import TelemetryServiceUtil from "../../Utils/TelemetryService";
 import ObjectID from "../../../Types/ObjectID";
 import OneUptimeDate from "../../../Types/Date";
 
@@ -460,6 +462,20 @@ const LogsViewer: FunctionComponent<ComponentProps> = (
           services[service.id.toString()] = service;
         });
 
+        /*
+         * Logs without a service.name are tagged with the projectId
+         * (ServiceType.Unknown) and have no Service row. Register a
+         * synthetic "Unknown Service" keyed by the projectId so the
+         * serviceId -> name resolution and the serviceId facet render
+         * "Unknown Service" instead of a raw id. Harmless when no logs
+         * are unattributed — nothing resolves against it.
+         */
+        const projectId: ObjectID | null = ProjectUtil.getCurrentProjectId();
+        if (projectId) {
+          services[projectId.toString()] =
+            TelemetryServiceUtil.getUnknownService(projectId);
+        }
+
         const hostsById: Dictionary<Host> = {};
         hosts.data.forEach((host: Host) => {
           if (!host.id) {

package/UI/Utils/Project.ts

@@ -12,6 +12,7 @@ import SubscriptionStatus, {
 } from "../../Types/Billing/SubscriptionStatus";
 import Navigation from "./Navigation";
 import SessionStorage from "./SessionStorage";
+import Telemetry from "./Telemetry/Telemetry";
 
 export default class ProjectUtil {
   public static getCurrentProjectId(): ObjectID | null {
@@ -107,6 +108,11 @@ export default class ProjectUtil {
     }
     LocalStorage.setItem(`project_${currentProjectId}`, project);
     SessionStorage.setItem(`current_project_id`, currentProjectId);
+
+    // Keep RUM span context in sync with the project being viewed.
+    if (currentProjectId) {
+      Telemetry.setGlobalAttributes({ projectId: currentProjectId });
+    }
   }
 
   public static clearCurrentProject(): void {

package/UI/Utils/Telemetry/Telemetry.ts

@@ -19,7 +19,65 @@ import type { SpanExporter as WebSpanExporter } from "@opentelemetry/sdk-trace-w
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import URL from "../../../Types/API/URL";
 
+/*
+ * Mutable, module-level bag of attributes stamped onto every browser span.
+ * Populated by `Telemetry.setGlobalAttributes` once the signed-in user and
+ * the project being viewed are known (RUM context).
+ */
+const globalSpanAttributes: { [key: string]: string } = {};
+
+interface MutableSpanLike {
+  setAttribute(key: string, value: string): unknown;
+}
+
+/**
+ * Stamps the global RUM attributes (userId, projectId, ...) onto each span at
+ * creation, mirroring the server-side ContextSpanProcessor.
+ */
+class GlobalAttributeSpanProcessor {
+  public onStart(span: MutableSpanLike): void {
+    for (const key in globalSpanAttributes) {
+      const value: string | undefined = globalSpanAttributes[key];
+
+      if (value) {
+        span.setAttribute(key, value);
+      }
+    }
+  }
+
+  public onEnd(): void {
+    // no-op
+  }
+
+  public forceFlush(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  public shutdown(): Promise<void> {
+    return Promise.resolve();
+  }
+}
+
 export default class Telemetry {
+  /**
+   * Set RUM attributes that should be attached to every browser span from now
+   * on (e.g. userId, projectId). Safe to call before or after `init`; empty
+   * values are ignored.
+   */
+  public static setGlobalAttributes(attributes: {
+    userId?: string | undefined;
+    projectId?: string | undefined;
+    [key: string]: string | undefined;
+  }): void {
+    for (const key in attributes) {
+      const value: string | undefined = attributes[key];
+
+      if (value) {
+        globalSpanAttributes[key] = value;
+      }
+    }
+  }
+
   public static init(data: { serviceName: string }): void {
     if (DisableTelemetry) {
       return;
@@ -49,6 +107,13 @@ export default class Telemetry {
 
       provider.addSpanProcessor(new BatchSpanProcessor(webTraceExporter));
 
+      // Stamp global RUM attributes (userId, projectId, ...) onto every span.
+      provider.addSpanProcessor(
+        new GlobalAttributeSpanProcessor() as unknown as Parameters<
+          WebTracerProvider["addSpanProcessor"]
+        >[0],
+      );
+
       provider.register({
         contextManager: new ZoneContextManager(),
       });

package/UI/Utils/TelemetryService.ts

@@ -0,0 +1,150 @@
+import Service from "../../Models/DatabaseModels/Service";
+import { Gray500 } from "../../Types/BrandColors";
+import ObjectID from "../../Types/ObjectID";
+import ServiceType from "../../Types/Telemetry/ServiceType";
+
+/*
+ * Telemetry that arrives without an OTel service.name (and with no
+ * host / docker / k8s resource signal) is not backed by a Service row.
+ * The ingest path tags those analytics rows with the projectId in the
+ * `serviceId` column under ServiceType.Unknown (see
+ * OtelIngestBaseService.resolveTelemetryResource). The read side has no
+ * Service to resolve, so we represent that telemetry with a synthetic,
+ * non-persisted Service whose id is the projectId — that way the
+ * existing serviceId -> Service lookups in the telemetry views resolve
+ * it to a labelled "Unknown Service" entry without any per-view special
+ * casing. A real Service._id is never equal to a projectId, so this
+ * never collides with a genuine service.
+ */
+export const UNKNOWN_SERVICE_NAME: string = "Unknown Service";
+
+/*
+ * Result of resolving a telemetry row's polymorphic (serviceId,
+ * serviceType) to something renderable. Either a Service (a real
+ * OpenTelemetry service, or the synthetic "Unknown Service" for the
+ * unattributed bucket) — or a plain `label` for infrastructure resource
+ * types (Host / DockerHost / KubernetesCluster) that have no Service row.
+ */
+export interface ResolvedTelemetryResource {
+  service?: Service;
+  label?: string;
+}
+
+export default class TelemetryServiceUtil {
+  /*
+   * True when a telemetry row's serviceId is the synthetic "Unknown
+   * Service" — i.e. it equals the projectId (ServiceType.Unknown). Used
+   * to suppress navigation to a per-service detail page that does not
+   * exist for unattributed telemetry.
+   */
+  public static isUnknownServiceId(
+    serviceId: ObjectID | string | null | undefined,
+    projectId: ObjectID | null | undefined,
+  ): boolean {
+    if (!serviceId || !projectId) {
+      return false;
+    }
+    return serviceId.toString() === projectId.toString();
+  }
+
+  /*
+   * Build the synthetic Service used to render unattributed telemetry.
+   * Not persisted — id is the projectId so that serviceId -> Service
+   * lookups (which key on the analytics row's serviceId) resolve to it.
+   */
+  public static getUnknownService(projectId: ObjectID): Service {
+    const service: Service = new Service();
+    service.id = projectId;
+    service.name = UNKNOWN_SERVICE_NAME;
+    service.serviceColor = Gray500;
+    return service;
+  }
+
+  /*
+   * Resolve a telemetry row's polymorphic (serviceId, serviceType) to a
+   * renderable resource, given the project's loaded Services. Replaces the
+   * old server-side `service` ORM relation on TelemetryException: a real
+   * Service resolves from the loaded list, the unattributed bucket resolves
+   * to the synthetic "Unknown Service", and Host / DockerHost /
+   * KubernetesCluster resolve to a type label (no Service row exists for
+   * them). Mirrors how the ClickHouse analytics rows are resolved.
+   */
+  public static resolveTelemetryResource(data: {
+    serviceId: ObjectID | string | null | undefined;
+    serviceType: ServiceType | string | null | undefined;
+    services: Array<Service>;
+    projectId: ObjectID | null | undefined;
+  }): ResolvedTelemetryResource {
+    const serviceIdStr: string | undefined = data.serviceId?.toString();
+
+    // Real Service (OpenTelemetry) — resolve from the loaded list.
+    if (serviceIdStr) {
+      const found: Service | undefined = data.services.find((s: Service) => {
+        return s.id?.toString() === serviceIdStr;
+      });
+      if (found) {
+        return { service: found };
+      }
+    }
+
+    // Unattributed (Unknown) bucket — serviceId is the projectId.
+    if (
+      data.projectId &&
+      (data.serviceType === ServiceType.Unknown ||
+        this.isUnknownServiceId(data.serviceId, data.projectId))
+    ) {
+      return { service: this.getUnknownService(data.projectId) };
+    }
+
+    // Infrastructure resource types — no Service row; render a type label.
+    const typeLabels: Record<string, string> = {
+      [ServiceType.Host]: "Host telemetry",
+      [ServiceType.DockerHost]: "Docker host telemetry",
+      [ServiceType.KubernetesCluster]: "Kubernetes telemetry",
+    };
+    const label: string | undefined = data.serviceType
+      ? typeLabels[data.serviceType.toString()]
+      : undefined;
+    if (label) {
+      return { label: label };
+    }
+
+    return { label: "Unknown" };
+  }
+
+  /*
+   * Append the synthetic "Unknown Service" to a loaded service list, but
+   * only when the telemetry in view actually references it (some
+   * serviceId equals the projectId). Avoids showing an empty "Unknown
+   * Service" entry for projects that always set service.name. Idempotent.
+   */
+  public static withUnknownServiceIfReferenced(data: {
+    services: Array<Service>;
+    referencedServiceIds: Iterable<string>;
+    projectId: ObjectID;
+  }): Array<Service> {
+    const projectIdStr: string = data.projectId.toString();
+
+    let isReferenced: boolean = false;
+    for (const id of data.referencedServiceIds) {
+      if (id === projectIdStr) {
+        isReferenced = true;
+        break;
+      }
+    }
+
+    if (!isReferenced) {
+      return data.services;
+    }
+
+    const alreadyPresent: boolean = data.services.some((service: Service) => {
+      return service.id?.toString() === projectIdStr;
+    });
+
+    if (alreadyPresent) {
+      return data.services;
+    }
+
+    return [...data.services, this.getUnknownService(data.projectId)];
+  }
+}

package/build/dist/Models/AnalyticsModels/ExceptionInstance.js

@@ -785,7 +785,7 @@ let ExceptionInstance = class ExceptionInstance extends AnalyticsBaseModel {
 };
 ExceptionInstance = __decorate([
     OperationalResource(),
-    OwnedThrough("serviceId", Service),
+    OwnedThrough("serviceId", Service, { includeProjectScope: true }),
     __metadata("design:paramtypes", [])
 ], ExceptionInstance);
 export default ExceptionInstance;