@oneuptime/common 12.0.8 → 12.0.9

package/Server/Services/LogAggregationService.ts

@@ -31,6 +31,7 @@ export interface HistogramRequest {
   bodySearchText?: string | undefined;
   traceIds?: Array<string> | undefined;
   spanIds?: Array<string> | undefined;
+  sessionIds?: Array<string> | undefined;
   attributes?: LogAttributeFilters | undefined;
 }
 
@@ -52,6 +53,7 @@ export interface FacetRequest {
   bodySearchText?: string | undefined;
   traceIds?: Array<string> | undefined;
   spanIds?: Array<string> | undefined;
+  sessionIds?: Array<string> | undefined;
   attributes?: LogAttributeFilters | undefined;
 }
 
@@ -72,6 +74,7 @@ export interface AnalyticsRequest {
   bodySearchText?: string | undefined;
   traceIds?: Array<string> | undefined;
   spanIds?: Array<string> | undefined;
+  sessionIds?: Array<string> | undefined;
   limit?: number | undefined;
 }
 
@@ -765,6 +768,7 @@ export class LogAggregationService {
       | "bodySearchText"
       | "traceIds"
       | "spanIds"
+      | "sessionIds"
       | "attributes"
     >,
   ): void {
@@ -817,6 +821,15 @@ export class LogAggregationService {
       );
     }
 
+    if (request.sessionIds && request.sessionIds.length > 0) {
+      statement.append(
+        SQL` AND sessionId IN (${{
+          type: TableColumnType.Text,
+          value: new Includes(request.sessionIds),
+        }})`,
+      );
+    }
+
     if (request.bodySearchText && request.bodySearchText.trim().length > 0) {
       statement.append(
         SQL` AND body ILIKE ${{
@@ -876,6 +889,7 @@ export class LogAggregationService {
     bodySearchText?: string | undefined;
     traceIds?: Array<string> | undefined;
     spanIds?: Array<string> | undefined;
+    sessionIds?: Array<string> | undefined;
     attributes?: Record<string, string> | undefined;
   }): Promise<Array<JSONObject>> {
     const maxLimit: number = Math.min(request.limit || 10000, 10000);
@@ -942,6 +956,7 @@ export class LogAggregationService {
     time: Date;
     logId: string;
     count: number;
+    sessionIds?: Array<string> | undefined;
   }): Promise<{ before: Array<JSONObject>; after: Array<JSONObject> }> {
     const count: number = Math.min(request.count || 5, 20);
 
@@ -975,11 +990,6 @@ export class LogAggregationService {
           value: request.logId,
         }}
         AND retentionDate >= now()
-      ORDER BY time DESC, timeUnixNano DESC
-      LIMIT ${{
-        type: TableColumnType.Number,
-        value: count,
-      }}
     `;
 
     const afterStatement: Statement = SQL`
@@ -1012,12 +1022,39 @@ export class LogAggregationService {
           value: request.logId,
         }}
         AND retentionDate >= now()
-      ORDER BY time ASC, timeUnixNano ASC
+    `;
+
+    /*
+     * Session scoping keeps "surrounding" logs within the same RUM
+     * session instead of interleaving every session the service handled
+     * at that instant.
+     */
+    if (request.sessionIds && request.sessionIds.length > 0) {
+      for (const contextStatement of [beforeStatement, afterStatement]) {
+        contextStatement.append(
+          SQL` AND sessionId IN (${{
+            type: TableColumnType.Text,
+            value: new Includes(request.sessionIds),
+          }})`,
+        );
+      }
+    }
+
+    beforeStatement.append(
+      SQL` ORDER BY time DESC, timeUnixNano DESC
       LIMIT ${{
         type: TableColumnType.Number,
         value: count,
-      }}
-    `;
+      }}`,
+    );
+
+    afterStatement.append(
+      SQL` ORDER BY time ASC, timeUnixNano ASC
+      LIMIT ${{
+        type: TableColumnType.Number,
+        value: count,
+      }}`,
+    );
 
     const [beforeResult, afterResult] = await Promise.all([
       LogDatabaseService.executeQuery(beforeStatement),

package/Server/Services/MetricAggregationService.ts

@@ -31,6 +31,25 @@ export interface FacetRequest extends MetricFilters {
   limit?: number | undefined;
 }
 
+export interface MetricsForTraceRequest {
+  projectId: ObjectID;
+  /** Exemplar traceId stamped on Metric rows (bloom-indexed). */
+  traceId: string;
+  /** Optional span-level narrowing within the trace (bloom-indexed). */
+  spanIds?: Array<string> | undefined;
+  limit?: number | undefined;
+}
+
+export interface MetricForTraceItem {
+  name: string;
+  time: string;
+  value: number;
+  spanId: string;
+  /** primaryEntityId of the row, stringified for the wire. */
+  serviceId: string;
+  attributes: JSONObject;
+}
+
 /*
  * Facet aggregation for the Metrics page sidebar. Same shape as
  * TraceAggregationService / LogAggregationService — per-facet GROUP BY on
@@ -61,6 +80,108 @@ export class MetricAggregationService {
     ]);
   private static readonly ATTRIBUTE_KEY_PATTERN: RegExp = /^[a-zA-Z0-9._:/-]+$/;
   private static readonly MAX_FACET_KEY_LENGTH: number = 256;
+  /**
+   * Cap on rows returned by the reverse exemplar lookup. A single trace
+   * rarely stamps more than a handful of exemplars, so hitting this cap
+   * means a pathological instrumentation loop — truncating is safe.
+   */
+  private static readonly MAX_METRICS_FOR_TRACE_LIMIT: number = 500;
+
+  /**
+   * Reverse exemplar lookup: every Metric row whose exemplar traceId
+   * matches the given trace (optionally narrowed to specific spans).
+   * Drives the "Metrics" tab on the trace detail view. traceId and
+   * spanId both carry bloom-filter skip indexes, so the read touches
+   * only the granules the index cannot rule out.
+   */
+  @CaptureSpan()
+  public static async getMetricsForTrace(
+    request: MetricsForTraceRequest,
+  ): Promise<Array<MetricForTraceItem>> {
+    const statement: Statement =
+      MetricAggregationService.buildMetricsForTraceStatement(request);
+
+    const dbResult: Results = await MetricService.executeQuery(statement);
+    const response: DbJSONResponse = await dbResult.json<{
+      data?: Array<JSONObject>;
+    }>();
+
+    const rows: Array<JSONObject> = response.data || [];
+
+    return rows.map((row: JSONObject): MetricForTraceItem => {
+      return {
+        name: String(row["name"] || ""),
+        time: String(row["time"] || ""),
+        value: Number(row["value"] || 0),
+        spanId: String(row["spanId"] || ""),
+        serviceId: String(row["serviceId"] || ""),
+        attributes: (row["attributes"] as JSONObject) || {},
+      };
+    });
+  }
+
+  private static buildMetricsForTraceStatement(
+    request: MetricsForTraceRequest,
+  ): Statement {
+    const limit: number = Math.min(
+      request.limit || MetricAggregationService.MAX_METRICS_FOR_TRACE_LIMIT,
+      MetricAggregationService.MAX_METRICS_FOR_TRACE_LIMIT,
+    );
+
+    const statement: Statement = SQL`
+      SELECT
+        name,
+        time,
+        toFloat64(value) AS value,
+        spanId,
+        toString(primaryEntityId) AS serviceId,
+        attributes
+      FROM ${MetricAggregationService.TABLE_NAME}
+      WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }}
+        AND traceId = ${{
+          type: TableColumnType.Text,
+          value: request.traceId,
+        }}
+    `;
+
+    if (request.spanIds && request.spanIds.length > 0) {
+      statement.append(
+        SQL` AND spanId IN (${{
+          type: TableColumnType.Text,
+          value: new Includes(request.spanIds),
+        }})`,
+      );
+    }
+
+    /*
+     * Read-side retention filter: rows past their per-service retention
+     * stay in their part until the whole part drops (ttl_only_drop_parts).
+     */
+    statement.append(" AND retentionDate >= now()");
+
+    statement.append(
+      SQL` ORDER BY time ASC LIMIT ${{
+        type: TableColumnType.Number,
+        value: limit,
+      }}`,
+    );
+
+    /*
+     * Cap runtime below the client's 58s request_timeout; 'break' yields
+     * partial rows rather than holding a pool connection.
+     */
+    statement.append(
+      getQuerySettings({
+        maxExecutionTimeInSeconds: 45,
+        timeoutOverflowMode: "break",
+      }),
+    );
+
+    return statement;
+  }
 
   @CaptureSpan()
   public static async getFacetValues(

package/Server/Services/MetricService.ts

@@ -30,8 +30,8 @@ import {
 import { keyForContainer } from "../Utils/Telemetry/TelemetryEntity";
 import { getEntityBudget } from "../Utils/Telemetry/EntityRegistry";
 import { EntityScopeQueryValue } from "../Utils/AnalyticsDatabase/StatementGenerator";
-import TelemetryEntityService from "./TelemetryEntityService";
-import TelemetryEntity from "../../Models/DatabaseModels/TelemetryEntity";
+import InventoryItemService from "./InventoryItemService";
+import InventoryItem from "../../Models/DatabaseModels/InventoryItem";
 import EntityType from "../../Types/Telemetry/EntityType";
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
@@ -298,7 +298,7 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
 
   /**
    * All serviceEntityKeys the ingest pipeline can have stamped for rows
-   * reporting this `service.name`, from the Postgres TelemetryEntity
+   * reporting this `service.name`, from the Postgres InventoryItem
    * registry. Service identity folds `service.namespace` into the key
    * when the resource carries one (see the service resolver in
    * Common/Server/Utils/Telemetry/TelemetryEntity), so one name maps to
@@ -324,7 +324,7 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     try {
       const canonicalName: string = canonicalizeEntityValue(serviceName);
 
-      const rows: Array<TelemetryEntity> = await TelemetryEntityService.findBy({
+      const rows: Array<InventoryItem> = await InventoryItemService.findBy({
         query: {
           projectId: new ObjectID(projectId),
           entityType: EntityType.Service,
@@ -358,7 +358,7 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
       /*
        * Budget-capped projects must not route. At/over the per-type
        * entity budget, ingest stops minting NEW Service registry rows
-       * forever (TelemetryEntityService.beforeCreate) while namespaced
+       * forever (InventoryItemService.beforeCreate) while namespaced
        * serviceEntityKeys keep flowing on signal rows — so a non-empty
        * registry key set may be PERMANENTLY missing identity variants,
        * and a routed `serviceEntityKey IN (...)` would silently return
@@ -368,7 +368,7 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
        * countBy amortizes to one per (project, service name) per minute.
        */
       const serviceEntityCount: PositiveNumber =
-        await TelemetryEntityService.countBy({
+        await InventoryItemService.countBy({
           query: {
             projectId: new ObjectID(projectId),
             entityType: EntityType.Service,
@@ -2220,7 +2220,7 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
    *   attributes == {resource.service.name: v}
    *     -> MetricItemAggMV1mByService, serviceEntityKey IN (<registry key set>)
    *        The key set is resolved asynchronously in aggregateBy() from
-   *        the Postgres TelemetryEntity registry — service identity folds
+   *        the Postgres InventoryItem registry — service identity folds
    *        service.namespace into the key at ingest, so one name can map
    *        to several keys. No registry rows -> NO routing (raw path).
    *   entityScope only, attributeKey in {host/k8s-cluster/container} and

package/Server/Services/NetworkDeviceLinkRuleService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/NetworkDeviceLinkRule";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/NetworkDeviceLinkService.ts

@@ -0,0 +1,84 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/NetworkDeviceLink";
+import NetworkDeviceService from "./NetworkDeviceService";
+import NetworkDevice from "../../Models/DatabaseModels/NetworkDevice";
+import { OnCreate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import QueryHelper from "../Types/Database/QueryHelper";
+import RelationIdUtil from "../Utils/Database/RelationIdUtil";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+
+// Both spellings of each end, for the same reason RelationIdUtil exists.
+const FROM_DEVICE_KEYS: Array<string> = ["fromDeviceId", "fromDevice"];
+const TO_DEVICE_KEYS: Array<string> = ["toDeviceId", "toDevice"];
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  /*
+   * Two guards, both about links that would be nonsense on the map:
+   *
+   *   - a device may not link to itself. The topology builder drops
+   *     self-edges anyway (the same rule LLDP self-reports hit), so such a
+   *     row would be invisible and permanently confusing.
+   *   - both ends must belong to the creating project. The FKs only require
+   *     the rows to exist, so without this a tenant could draw a line to
+   *     another project's device and read its name off the map.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    const data: Record<string, unknown> = createBy.data as unknown as Record<
+      string,
+      unknown
+    >;
+
+    const fromDeviceId: ObjectID | null = RelationIdUtil.read(
+      data,
+      FROM_DEVICE_KEYS,
+    );
+    const toDeviceId: ObjectID | null = RelationIdUtil.read(
+      data,
+      TO_DEVICE_KEYS,
+    );
+
+    if (!fromDeviceId || !toDeviceId) {
+      throw new BadDataException("A link needs a device at each end.");
+    }
+
+    if (fromDeviceId.toString() === toDeviceId.toString()) {
+      throw new BadDataException("A device cannot be linked to itself.");
+    }
+
+    if (!createBy.data.projectId) {
+      throw new BadDataException("Project ID is required.");
+    }
+
+    const devices: Array<NetworkDevice> = await NetworkDeviceService.findBy({
+      query: {
+        _id: QueryHelper.any([fromDeviceId.toString(), toDeviceId.toString()]),
+        projectId: createBy.data.projectId,
+      },
+      select: { _id: true },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: { isRoot: true },
+    });
+
+    if (devices.length !== 2) {
+      throw new BadDataException(
+        "Both devices must exist and belong to this project.",
+      );
+    }
+
+    return { createBy, carryForward: null };
+  }
+}
+
+export default new Service();

package/Server/Services/NetworkDeviceService.ts

@@ -1,9 +1,11 @@
 import DatabaseService from "./DatabaseService";
+import MonitorService from "./MonitorService";
 import NetworkDeviceLabelRuleEngineService from "./NetworkDeviceLabelRuleEngineService";
 import NetworkDeviceOwnerRuleEngineService from "./NetworkDeviceOwnerRuleEngineService";
 import NetworkSiteAssignmentRuleService from "./NetworkSiteAssignmentRuleService";
 import NetworkSiteService from "./NetworkSiteService";
 import Model from "../../Models/DatabaseModels/NetworkDevice";
+import Monitor from "../../Models/DatabaseModels/Monitor";
 import NetworkSite from "../../Models/DatabaseModels/NetworkSite";
 import NetworkSiteAssignmentRule from "../../Models/DatabaseModels/NetworkSiteAssignmentRule";
 import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
@@ -18,6 +20,7 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import OneUptimeDate from "../../Types/Date";
 import CidrMatchUtil from "../../Utils/NetworkSite/CidrMatchUtil";
+import { NetworkDeviceMonitoringMethodUtil } from "../../Types/NetworkDevice/NetworkDeviceMonitoringMethod";
 import RelationIdUtil from "../Utils/Database/RelationIdUtil";
 import { EntityManager } from "typeorm";
 
@@ -68,6 +71,13 @@ function readSiteIdFromData(data: Record<string, unknown>): ObjectID | null {
   return RelationIdUtil.read(data, SITE_KEYS);
 }
 
+// Both spellings of "the monitor that reports this device's health".
+const MONITOR_KEYS: Array<string> = ["monitorId", "monitor"];
+
+function readMonitorIdFromData(data: Record<string, unknown>): ObjectID | null {
+  return RelationIdUtil.read(data, MONITOR_KEYS);
+}
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -152,9 +162,71 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
+    if (
+      NetworkDeviceMonitoringMethodUtil.isMonitorBacked(
+        createBy.data.monitoringMethod,
+      )
+    ) {
+      const monitorId: ObjectID | null = readMonitorIdFromData(
+        createBy.data as unknown as Record<string, unknown>,
+      );
+
+      /*
+       * The monitor is NOT required here, though the create form asks for
+       * one. Discovery import is why: a subnet sweep finds ping-only hosts
+       * in bulk and there is no monitor to bind them to yet. Such a device
+       * is still worth recording — it belongs to a site, carries labels, and
+       * appears on the topology map — and its status reads "pending", which
+       * is exactly true until somebody points a monitor at it.
+       */
+      if (monitorId) {
+        await this.assertMonitorBelongsToProject({
+          monitorId: monitorId,
+          projectId: createBy.data.projectId,
+        });
+      }
+
+      /*
+       * Not a preference: a monitor-backed device has no probe and no
+       * credentials, so leaving polling on would queue a walk that can only
+       * ever fail. claimDevicesForPolling refuses these rows too — this is
+       * the half that keeps the column honest for anything reading it.
+       */
+      createBy.data.isPollingEnabled = false;
+    }
+
     return { createBy, carryForward: null };
   }
 
+  /*
+   * The FK behind monitorId only requires the Monitor row to exist, not that
+   * it belongs to the device's project — the same hole assertSiteBelongsToProject
+   * closes for sites. Without this a tenant could bind a device to another
+   * project's monitor and read its status through the device.
+   */
+  @CaptureSpan()
+  private async assertMonitorBelongsToProject(data: {
+    monitorId: ObjectID;
+    projectId: ObjectID | undefined;
+  }): Promise<void> {
+    if (!data.projectId) {
+      throw new BadDataException("Project ID is required.");
+    }
+
+    const monitor: Monitor | null = await MonitorService.findOneBy({
+      query: {
+        _id: data.monitorId,
+        projectId: data.projectId,
+      },
+      select: { _id: true },
+      props: { isRoot: true },
+    });
+
+    if (!monitor) {
+      throw new BadDataException("Monitor not found.");
+    }
+  }
+
   /*
    * Owner/label rules fire whenever a device is created — manually or via
    * subnet discovery import. Applied out-of-band: rule failures must never
@@ -222,6 +294,71 @@ export class Service extends DatabaseService<Model> {
   ): Promise<OnUpdate<Model>> {
     const dataKeys: Array<string> = Object.keys(updateBy.data || {});
 
+    /*
+     * Switching a device to monitor-backed turns polling off with it. The
+     * two are one decision, not two: a device with no probe and no
+     * credentials cannot be walked, so leaving the flag on would queue a
+     * walk per interval that can only fail and then paint the device down.
+     */
+    const isMethodWrite: boolean = dataKeys.includes("monitoringMethod");
+    /*
+     * An update payload is a QueryDeepPartialEntity, so a column can hold a
+     * raw value OR a SQL-expression function. Only a plain string is a
+     * method we can reason about; anything else falls through to the SNMP
+     * default, which changes nothing.
+     */
+    const writtenMethod: unknown = (
+      updateBy.data as unknown as Record<string, unknown>
+    )["monitoringMethod"];
+    const becomesMonitorBacked: boolean =
+      isMethodWrite &&
+      typeof writtenMethod === "string" &&
+      NetworkDeviceMonitoringMethodUtil.isMonitorBacked(writtenMethod);
+
+    if (becomesMonitorBacked) {
+      updateBy.data.isPollingEnabled = false;
+    }
+
+    /*
+     * Turning polling back ON is the other direction, and it has to be
+     * refused rather than quietly ignored: claimDevicesForPolling skips
+     * monitor-backed rows whatever this column says, so a device left with
+     * the flag on would read "polling enabled" in the UI forever while
+     * nothing ever polled it. Only checked when the payload actually asks
+     * for it, so the ordinary update path costs no extra query.
+     */
+    if (
+      !becomesMonitorBacked &&
+      dataKeys.includes("isPollingEnabled") &&
+      updateBy.data.isPollingEnabled === true
+    ) {
+      const targets: Array<Model> = await this.findBy({
+        query: this.scopeQueryToCallerTenant(updateBy.query, updateBy.props),
+        select: {
+          _id: true,
+          monitoringMethod: true,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      const isTargetMonitorBacked: boolean = targets.some((target: Model) => {
+        return NetworkDeviceMonitoringMethodUtil.isMonitorBacked(
+          target.monitoringMethod,
+        );
+      });
+
+      // Unless the same write is moving it back to SNMP, which is allowed.
+      if (isTargetMonitorBacked && !(isMethodWrite && !becomesMonitorBacked)) {
+        throw new BadDataException(
+          "This device is monitor-backed, so there is nothing to poll — it has no probe and no SNMP credentials. Switch its monitoring method to SNMP first.",
+        );
+      }
+    }
+
     const isSiteChange: boolean = isSiteWrite(dataKeys);
     const isIdentityChange: boolean = SITE_RULE_IDENTITY_COLUMNS.some(
       (column: string) => {
@@ -545,6 +682,9 @@ export class Service extends DatabaseService<Model> {
           AND nd."isPollingEnabled" = true
           AND nd."deletedAt" IS NULL
           AND nd."hostname" IS NOT NULL
+          -- A monitor-backed device has no credentials to walk with. NULL is
+          -- every device created before the column existed: those are SNMP.
+          AND (nd."monitoringMethod" IS NULL OR nd."monitoringMethod" <> 'Monitor')
           AND (nd."nextPollAt" IS NULL OR nd."nextPollAt" <= $2)
           AND p."deletedAt" IS NULL
           AND (p."paymentProviderSubscriptionStatus" IS NULL