@oneuptime/common 12.0.7 → 12.0.9

package/Server/Services/{TelemetryEntityService.ts → InventoryItemService.ts}

@@ -1,5 +1,5 @@
 import DatabaseService from "./DatabaseService";
-import Model from "../../Models/DatabaseModels/TelemetryEntity";
+import Model from "../../Models/DatabaseModels/InventoryItem";
 import Service from "../../Models/DatabaseModels/Service";
 import ServiceService from "./ServiceService";
 import QueryHelper from "../Types/Database/QueryHelper";
@@ -8,8 +8,19 @@ import ObjectID from "../../Types/ObjectID";
 import OneUptimeDate from "../../Types/Date";
 import ColumnLength from "../../Types/Database/ColumnLength";
 import QueryDeepPartialEntity from "../../Types/Database/PartialEntity";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate } from "../Types/Database/Hooks";
+import BadDataException from "../../Types/Exception/BadDataException";
+import Dictionary from "../../Types/Dictionary";
 import { JSONObject } from "../../Types/JSON";
+import EntitySource from "../../Types/Telemetry/EntitySource";
 import EntityType from "../../Types/Telemetry/EntityType";
+import { MANUAL_ENTITY_TYPES } from "../../Types/Telemetry/EntityTypeGroups";
+import {
+  canonicalizeEntityValue,
+  computeEntityKey,
+  MANUAL_ENTITY_IDENTITY_ATTRIBUTE,
+} from "../../Utils/Telemetry/EntityKey";
 import logger from "../Utils/Logger";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { ExtractedEntity } from "../Utils/Telemetry/TelemetryEntity";
@@ -20,11 +31,96 @@ import {
   shouldWarnEntityBudgetOnce,
 } from "../Utils/Telemetry/EntityRegistry";
 
-export class TelemetryEntityService extends DatabaseService<Model> {
+export class InventoryItemService extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
 
+  /**
+   * Completes a manually created CI.
+   *
+   * Every machine writer — the ingest reconciler and the inventory mirror —
+   * computes `entityKey` itself and passes an explicit `source`, because
+   * both derive identity from something the user never sees (a canonicalized
+   * semconv attribute set, or the owning row's id). A create arriving
+   * WITHOUT a key is therefore a user create by construction, and this hook
+   * is what turns the two fields a human can reasonably supply (type and
+   * name) into the identity the registry needs.
+   *
+   * Deriving the key here rather than in the dashboard keeps it enforced for
+   * API clients too, and keeps the one identity rule — canonicalize, then
+   * hash — in the module that owns it.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    const data: Model = createBy.data;
+
+    if (!data.entityKey) {
+      data.source = EntitySource.Manual;
+    }
+
+    if (data.source !== EntitySource.Manual) {
+      return { createBy, carryForward: null };
+    }
+
+    if (!data.projectId) {
+      throw new BadDataException("Project ID is required.");
+    }
+
+    if (!data.entityType) {
+      throw new BadDataException("Entity Type is required.");
+    }
+
+    /*
+     * Confined to the manual-only vocabulary. A hand-made row of an
+     * observable type would key off the manual identity attribute and so
+     * could never converge with the row ingest derives for the same thing —
+     * it would just sit beside it forever. See MANUAL_ENTITY_TYPES.
+     */
+    if (!MANUAL_ENTITY_TYPES.has(data.entityType)) {
+      throw new BadDataException(
+        `Entities of type ${data.entityType} are discovered automatically and cannot be created manually. Manually creatable types are: ${Array.from(
+          MANUAL_ENTITY_TYPES,
+        ).join(", ")}.`,
+      );
+    }
+
+    const displayName: string = (data.displayName || "").trim();
+
+    if (!displayName) {
+      throw new BadDataException(
+        "Name is required for a manually created entity.",
+      );
+    }
+
+    data.displayName = displayName.substring(0, ColumnLength.ShortText);
+
+    const identifyingAttributes: Dictionary<string> = {
+      [MANUAL_ENTITY_IDENTITY_ATTRIBUTE]: canonicalizeEntityValue(displayName),
+    };
+    data.identifyingAttributes = identifyingAttributes as JSONObject;
+
+    data.entityKey = computeEntityKey({
+      projectId: data.projectId.toString(),
+      entityType: data.entityType,
+      identifyingAttributes,
+    });
+
+    /*
+     * Stamped so the explorer can sort manual CIs alongside discovered ones
+     * on the same columns. `lastSeenAt` never moves again for these rows —
+     * it means "created", not "observed" — which is exactly why the prune
+     * sweep excludes them.
+     */
+    const now: Date = OneUptimeDate.getCurrentDate();
+    data.firstSeenAt = data.firstSeenAt || now;
+    data.lastSeenAt = data.lastSeenAt || now;
+
+    return { createBy, carryForward: null };
+  }
+
   /**
    * Forward-only registry reconciliation: upsert a catalog row per
    * discovered entity, bump `lastSeenAt`, merge descriptive attributes
@@ -65,7 +161,7 @@ export class TelemetryEntityService extends DatabaseService<Model> {
         });
       } catch (err) {
         logger.error(
-          `TelemetryEntityService: failed to upsert entity ${entity.entityType}/${entity.entityKey}:`,
+          `InventoryItemService: failed to upsert entity ${entity.entityType}/${entity.entityKey}:`,
         );
         logger.error(err as Error);
       }
@@ -88,7 +184,7 @@ export class TelemetryEntityService extends DatabaseService<Model> {
     if (data.entity.entityType !== EntityType.Service) {
       return null;
     }
-    const name: string = TelemetryEntityService.deriveDisplayName(data.entity);
+    const name: string = InventoryItemService.deriveDisplayName(data.entity);
     if (!name) {
       return null;
     }
@@ -110,7 +206,7 @@ export class TelemetryEntityService extends DatabaseService<Model> {
       return service?._id ? new ObjectID(service._id.toString()) : null;
     } catch (err) {
       logger.error(
-        `TelemetryEntityService: failed to resolve Service row for entity name "${name}":`,
+        `InventoryItemService: failed to resolve Service row for entity name "${name}":`,
       );
       logger.error(err as Error);
       return null;
@@ -138,10 +234,15 @@ export class TelemetryEntityService extends DatabaseService<Model> {
       lastSeenAt: now,
       describe: `entity ${entity.entityType}/${entity.entityKey}`,
       rowFenceId: `${projectId.toString()}:${entity.entityType}:${entity.entityKey}`,
-      select: { descriptiveAttributes: true, labels: true, resourceId: true },
+      select: {
+        displayName: true,
+        descriptiveAttributes: true,
+        labels: true,
+        resourceId: true,
+      },
       buildUpdate: (existing: Model): QueryDeepPartialEntity<Model> => {
         const update: QueryDeepPartialEntity<Model> =
-          TelemetryEntityService.buildDescriptiveUpdate(entity, existing);
+          InventoryItemService.buildDescriptiveUpdate(entity, existing);
         /*
          * Stamp / refresh the pointer on the throttled bump too, so
          * pre-existing rows converge and a deleted+recreated Service
@@ -169,7 +270,18 @@ export class TelemetryEntityService extends DatabaseService<Model> {
         if (count === undefined) {
           count = (
             await this.countBy({
-              query: { projectId, entityType: entity.entityType },
+              query: {
+                projectId,
+                entityType: entity.entityType,
+                /*
+                 * The budget exists to bound rows minted by ingest, so it
+                 * counts only those. Manual CIs and inventory mirrors are
+                 * bounded by their own creators and must not consume it —
+                 * otherwise registering enough devices could stop new
+                 * telemetry entities being recorded at all.
+                 */
+                source: EntitySource.Discovered,
+              },
               props: { isRoot: true },
             })
           ).toNumber();
@@ -188,7 +300,7 @@ export class TelemetryEntityService extends DatabaseService<Model> {
           })
         ) {
           logger.warn(
-            `TelemetryEntityService: entity budget reached for project ${projectId.toString()} type ${entity.entityType} (${count} >= ${budget}); skipping new registry rows. Membership keys still flow on signals.`,
+            `InventoryItemService: entity budget reached for project ${projectId.toString()} type ${entity.entityType} (${count} >= ${budget}); skipping new registry rows. Membership keys still flow on signals.`,
           );
         }
         return false;
@@ -198,6 +310,12 @@ export class TelemetryEntityService extends DatabaseService<Model> {
         model.projectId = projectId;
         model.entityType = entity.entityType;
         model.entityKey = entity.entityKey;
+        /*
+         * Explicit rather than leaning on the column default: this is the
+         * flag that makes the row eligible for stale-entity pruning, and a
+         * silently-defaulted value is a poor way to carry that.
+         */
+        model.source = EntitySource.Discovered;
         model.identifyingAttributes = entity.identifyingAttributes;
         if (
           entity.descriptiveAttributes &&
@@ -206,10 +324,10 @@ export class TelemetryEntityService extends DatabaseService<Model> {
           model.descriptiveAttributes = entity.descriptiveAttributes;
         }
         if (entity.labels && entity.labels.length > 0) {
-          model.labels = TelemetryEntityService.normalizeLabels(entity.labels);
+          model.labels = InventoryItemService.normalizeLabels(entity.labels);
         }
         // varchar(ShortText) column; k8s names can run to 253 chars.
-        model.displayName = TelemetryEntityService.deriveDisplayName(
+        model.displayName = InventoryItemService.deriveDisplayName(
           entity,
         ).substring(0, ColumnLength.ShortText);
         if (serviceResourceId) {
@@ -224,11 +342,11 @@ export class TelemetryEntityService extends DatabaseService<Model> {
   }
 
   /**
-   * Extra fields for the `lastSeenAt` bump on an existing row:
-   * descriptive attributes merge last-writer-wins per key, labels merge
-   * as a set union. Both are written ONLY when the merge actually changes
-   * the stored value, so a stable resource keeps its bump a one-column
-   * update (no jsonb churn).
+   * Extra fields for the `lastSeenAt` bump on an existing row: a legacy
+   * generated Kubernetes fallback display name can converge to the resource
+   * name, descriptive attributes merge last-writer-wins per key, and labels
+   * merge as a set union. Each is written ONLY when it actually changes, so a
+   * stable resource keeps its bump a one-column update (no text/jsonb churn).
    */
   private static buildDescriptiveUpdate(
     entity: ExtractedEntity,
@@ -240,10 +358,45 @@ export class TelemetryEntityService extends DatabaseService<Model> {
      * recursive JSONObject mapping (TS2589).
      */
     const update: {
+      displayName?: string;
       descriptiveAttributes?: JSONObject;
       labels?: Array<string>;
     } = {};
 
+    const preferredNameKey: string | undefined =
+      InventoryItemService.preferredDisplayNameAttributeByType[
+        entity.entityType
+      ];
+    /*
+     * Existing inventory display names may be user-edited. Only migrate a
+     * pod/node row when its current value is exactly the value the old generic
+     * algorithm generated. A sparse observation cannot erase a learned name,
+     * and an unrelated entity type never has its display name reconciled here.
+     */
+    const preferredName: string | undefined = preferredNameKey
+      ? entity.descriptiveAttributes?.[preferredNameKey] ||
+        entity.identifyingAttributes?.[preferredNameKey]
+      : undefined;
+    if (preferredName) {
+      const desiredDisplayName: string = preferredName.substring(
+        0,
+        ColumnLength.ShortText,
+      );
+      const legacyDisplayName: string =
+        InventoryItemService.deriveFallbackDisplayName(entity).substring(
+          0,
+          ColumnLength.ShortText,
+        );
+      const existingDisplayName: string = existing.displayName || "";
+
+      if (
+        existingDisplayName !== desiredDisplayName &&
+        (!existingDisplayName || existingDisplayName === legacyDisplayName)
+      ) {
+        update.displayName = desiredDisplayName;
+      }
+    }
+
     const incoming: Record<string, string> = entity.descriptiveAttributes || {};
     if (Object.keys(incoming).length > 0) {
       const current: Record<string, unknown> =
@@ -271,7 +424,7 @@ export class TelemetryEntityService extends DatabaseService<Model> {
       });
 
       if (hasNew) {
-        update.labels = TelemetryEntityService.normalizeLabels([
+        update.labels = InventoryItemService.normalizeLabels([
           ...currentLabels,
           ...incomingLabels,
         ]);
@@ -286,13 +439,42 @@ export class TelemetryEntityService extends DatabaseService<Model> {
     return Array.from(new Set<string>(labels)).sort();
   }
 
+  private static readonly preferredDisplayNameAttributeByType: Partial<
+    Record<EntityType, string>
+  > = {
+    [EntityType.KubernetesNode]: "k8s.node.name",
+    [EntityType.KubernetesPod]: "k8s.pod.name",
+  };
+
   /**
-   * Best-effort human-readable name for the entity explorer: prefer the
-   * most specific `*.name` identifying attribute (e.g. k8s.pod.name over
-   * k8s.cluster.name), else the last identifying value, else the key.
+   * Best-effort human-readable name for Inventory. Prefer the name belonging
+   * to this exact entity type, including a descriptive name paired with a
+   * stable UID identity (the normal Kubernetes pod/node shape). Falling back
+   * to the longest identifying `*.name` preserves the behaviour for types
+   * without a dedicated display-name rule.
    */
   public static deriveDisplayName(entity: ExtractedEntity): string {
     const id: Record<string, string> = entity.identifyingAttributes || {};
+    const descriptive: Record<string, string> =
+      entity.descriptiveAttributes || {};
+    const preferredKey: string | undefined =
+      this.preferredDisplayNameAttributeByType[entity.entityType];
+
+    if (preferredKey) {
+      const preferredValue: string | undefined =
+        descriptive[preferredKey] || id[preferredKey];
+      if (preferredValue) {
+        return preferredValue;
+      }
+    }
+
+    return this.deriveFallbackDisplayName(entity);
+  }
+
+  /** The generic display-name algorithm used before type-aware K8s names. */
+  private static deriveFallbackDisplayName(entity: ExtractedEntity): string {
+    const id: Record<string, string> = entity.identifyingAttributes || {};
+
     const nameKeys: Array<string> = Object.keys(id)
       .filter((k: string) => {
         return k.endsWith(".name");
@@ -314,4 +496,4 @@ export class TelemetryEntityService extends DatabaseService<Model> {
   }
 }
 
-export default new TelemetryEntityService();
+export default new InventoryItemService();

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();