@oneuptime/common 14.0.13 → 14.0.14

package/Server/Services/OnCallSetupReminderService.ts

@@ -22,6 +22,10 @@ import Email from "../../Types/Email";
 import EmailTemplateType from "../../Types/Email/EmailTemplateType";
 import BadDataException from "../../Types/Exception/BadDataException";
 import NotificationRuleType from "../../Types/NotificationRule/NotificationRuleType";
+import {
+  OnCallRulesLink,
+  getUserSettingsOnCallRulesLink,
+} from "../../Types/NotificationRule/OnCallRuleKind";
 import ObjectID from "../../Types/ObjectID";
 import Project from "../../Models/DatabaseModels/Project";
 import TeamMember from "../../Models/DatabaseModels/TeamMember";
@@ -175,21 +179,18 @@ const REMINDER_THROTTLE_NAMESPACE: string = "oncall-setup-reminder";
 const THROTTLE_MAX_ENTRIES: number = 10_000;
 
 /*
- * Dashboard user-settings path segments, duplicated from the Dashboard's
- * UserSettingsRoutePath.
+ * The Notification Methods page's path segment, duplicated from the
+ * Dashboard's UserSettingsRoutePath.
  *
  * Common/Server cannot import App sources, which is why
- * OnCallDutyPolicyService.getOnCallDutyPolicyLinkInDashboard and
- * OnCallNotificationAlertingService both spell their routes out by hand too. The
- * duplication is a known cost; sending somebody a link to the wrong settings tab
- * is a worse one, because a reminder that lands on a page with nothing wrong on
- * it reads as "this system is confused" and gets ignored.
+ * OnCallDutyPolicyService.getOnCallDutyPolicyLinkInDashboard spells its route
+ * out by hand too. The On-Call Rules page's address - its path and the
+ * `?type=` that opens a kind's tab - comes from Common's OnCallRuleKind, which
+ * the dashboard reads as well. Sending somebody a link to the wrong settings
+ * tab is the cost worth avoiding: a reminder that lands on a page with
+ * nothing wrong on it reads as "this system is confused" and gets ignored.
  */
 const NOTIFICATION_METHODS_PATH: string = "notification-methods";
-const INCIDENT_RULES_PATH: string = "incident-on-call-rules";
-const INCIDENT_EPISODE_RULES_PATH: string = "incident-episode-on-call-rules";
-const ALERT_RULES_PATH: string = "alert-on-call-rules";
-const ALERT_EPISODE_RULES_PATH: string = "alert-episode-on-call-rules";
 
 /*
  * How many reason lines a reminder carries before it stops listing them.
@@ -837,14 +838,37 @@ export class OnCallSetupReminderService extends BaseService {
     context: ReminderContext,
     readiness: UserReadiness,
   ): URL {
-    return URL.fromString(context.dashboardUrl.toString()).addRoute(
-      `/${context.projectId.toString()}/user-settings/${this.getSettingsPath(readiness)}`,
-    );
+    /*
+     * The On-Call Rules page, opened on the tab that holds the first hole.
+     * No hole to name, or a rule type this build has not heard of: the
+     * Notification Methods page, the one that is relevant to every gap there
+     * could ever be, rather than a guess about which tab it belongs on.
+     */
+    const rulesLink: OnCallRulesLink | null = getUserSettingsOnCallRulesLink({
+      projectId: context.projectId.toString(),
+      ruleType: this.getRuleTypeToFix(readiness),
+    });
+
+    if (!rulesLink) {
+      return URL.fromString(context.dashboardUrl.toString()).addRoute(
+        `/${context.projectId.toString()}/user-settings/${NOTIFICATION_METHODS_PATH}`,
+      );
+    }
+
+    return URL.fromString(context.dashboardUrl.toString())
+      .addRoute(rulesLink.path)
+      .addQueryParams(rulesLink.query);
   }
 
-  private getSettingsPath(readiness: UserReadiness): string {
+  /*
+   * The rule type of the first hole, or null when the fix is a notification
+   * method rather than a rule.
+   */
+  private getRuleTypeToFix(
+    readiness: UserReadiness,
+  ): NotificationRuleType | null {
     if (readiness.status === ReadinessStatus.NotReachable) {
-      return NOTIFICATION_METHODS_PATH;
+      return null;
     }
 
     const firstGap: ReadinessCoverageCell | undefined = readiness.coverage.find(
@@ -853,30 +877,7 @@ export class OnCallSetupReminderService extends BaseService {
       },
     );
 
-    if (!firstGap) {
-      return NOTIFICATION_METHODS_PATH;
-    }
-
-    switch (firstGap.ruleType) {
-      case NotificationRuleType.ON_CALL_EXECUTED_ALERT:
-        return ALERT_RULES_PATH;
-      case NotificationRuleType.ON_CALL_EXECUTED_ALERT_EPISODE:
-        return ALERT_EPISODE_RULES_PATH;
-      case NotificationRuleType.ON_CALL_EXECUTED_INCIDENT_EPISODE:
-        return INCIDENT_EPISODE_RULES_PATH;
-      case NotificationRuleType.ON_CALL_EXECUTED_INCIDENT:
-      case NotificationRuleType.WHEN_USER_GOES_ON_CALL:
-      case NotificationRuleType.WHEN_USER_GOES_OFF_CALL:
-        return INCIDENT_RULES_PATH;
-      default:
-        /*
-         * A rule type this build has not heard of. Notification Methods is the
-         * one page that is relevant to every gap there could ever be, so an
-         * unknown type degrades to "somewhere useful" rather than to a guess
-         * about which settings tab it belongs on.
-         */
-        return NOTIFICATION_METHODS_PATH;
-    }
+    return firstGap ? firstGap.ruleType : null;
   }
 
   private tally(

package/Server/Services/PodmanHostService.ts

@@ -20,6 +20,15 @@ import { JSONObject } from "../../Types/JSON";
 import URL from "../../Types/API/URL";
 import DatabaseConfig from "../DatabaseConfig";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import DiscoveredResourceCreate, {
+  DiscoveredResourceNaming,
+  NamedAfterIdentityOptions,
+  namedAfterIdentity,
+} from "../Utils/Telemetry/DiscoveredResourceCreate";
+import DiscoveredResourceUpdate, {
+  MatchColumn,
+  matchedOnIdentifier,
+} from "../Utils/Telemetry/DiscoveredResourceUpdate";
 import ResourceHeartbeat from "../Utils/Telemetry/ResourceHeartbeat";
 import ObjectID from "../../Types/ObjectID";
 import QueryHelper from "../Types/Database/QueryHelper";
@@ -35,6 +44,23 @@ const LAST_SEEN_THROTTLE_SECONDS: number = 60;
 const LABELS_APPLIED_CACHE_NAMESPACE: string = "podman-host-labels-applied";
 const LABELS_APPLIED_CACHE_TTL_SECONDS: number = 60;
 
+/*
+ * A Podman host is matched to its telemetry by host.name, and named after it
+ * unless somebody gives it a display name of their own
+ * (DiscoveredResourceCreate).
+ */
+const PODMAN_HOST_IDENTITY: NamedAfterIdentityOptions = {
+  identityColumn: "hostIdentifier",
+  resourceName: "Podman host",
+  identityName: "host name",
+};
+
+const PODMAN_HOST_NAMING: DiscoveredResourceNaming<Model> =
+  namedAfterIdentity<Model>(PODMAN_HOST_IDENTITY);
+
+const PODMAN_HOST_MATCH_COLUMN: MatchColumn =
+  matchedOnIdentifier(PODMAN_HOST_IDENTITY);
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -530,9 +556,43 @@ export class Service extends DatabaseService<Model> {
       createBy,
     });
 
+    // Named after its host name when nobody gave it a name.
+    DiscoveredResourceCreate.fillName({ createBy, naming: PODMAN_HOST_NAMING });
+
     return { createBy, carryForward: null };
   }
 
+  /*
+   * A Podman host that is already there - discovered from its telemetry or
+   * added before - is refused by its host name, not as a clash of names.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreateUniqueCheck(
+    createBy: CreateBy<Model>,
+  ): Promise<void> {
+    await DiscoveredResourceCreate.refuseClash({
+      service: this,
+      createBy,
+      naming: PODMAN_HOST_NAMING,
+    });
+  }
+
+  /*
+   * A Podman host's host name - edited from the details card on its Settings page - is stored
+   * without the spaces around it, and refused when another one of the
+   * project already has it (DiscoveredResourceUpdate).
+   */
+  @CaptureSpan()
+  protected override async onBeforeUpdateUniqueCheck(
+    updateBy: UpdateBy<Model>,
+  ): Promise<void> {
+    await DiscoveredResourceUpdate.checkMatchColumn({
+      service: this,
+      updateBy,
+      matchColumn: PODMAN_HOST_MATCH_COLUMN,
+    });
+  }
+
   /*
    * An operator's write of an AI access setting (the investigation switch, the
    * remediation mode, the command allowlist) is validated and checked against

package/Server/Services/ProfileAggregationService.ts

@@ -286,6 +286,7 @@ export class ProfileAggregationService {
   private static readonly TABLE_NAME: string = AnalyticsTableName.ProfileSample;
   private static readonly PROFILE_TABLE_NAME: string =
     AnalyticsTableName.Profile;
+  private static readonly SPAN_TABLE_NAME: string = AnalyticsTableName.Span;
   private static readonly DEFAULT_FUNCTION_LIST_LIMIT: number = 50;
   private static readonly DEFAULT_BREAKDOWN_LIMIT: number = 10;
   /**
@@ -1312,6 +1313,8 @@ export class ProfileAggregationService {
           value: new Includes(request.spanIds),
         }})`,
       );
+    } else {
+      ProfileAggregationService.appendTraceSpansFilter(statement, request);
     }
 
     /*
@@ -1540,6 +1543,11 @@ export class ProfileAggregationService {
           value: new Includes(request.spanIds),
         }})`,
       );
+    } else if (request.traceId) {
+      ProfileAggregationService.appendTraceSpansFilter(statement, {
+        projectId: request.projectId,
+        traceId: request.traceId,
+      });
     }
 
     /*
@@ -1551,6 +1559,36 @@ export class ProfileAggregationService {
     ProfileAggregationService.appendCommonFilters(statement, request);
   }
 
+  /**
+   * A trace-wide read (a traceId without spanIds) counts a sample only
+   * when the sample names one of the trace's own spans, as a span-scoped
+   * read already does. A sample's link is whatever span context the
+   * profiler found for its thread, and OBI v0.14.0 can publish context for
+   * threads of processes it does not instrument: such a caller of an
+   * instrumented service keeps the context of its last call, under a span
+   * of its own that was never exported, so all its later CPU would land in
+   * this trace. Samples linked to spans dropped before storage (database
+   * server spans, for instance) are left out as well.
+   *
+   * GLOBAL IN, not plain IN: both tables are Distributed and shard on
+   * different keys (spans by traceId, samples by profileId), so a plain IN
+   * is rejected on multi-shard clusters (Code 288).
+   */
+  private static appendTraceSpansFilter(
+    statement: Statement,
+    request: Pick<TracePresenceRequest, "projectId" | "traceId">,
+  ): void {
+    statement.append(
+      SQL` AND spanId GLOBAL IN (SELECT spanId FROM ${ProfileAggregationService.SPAN_TABLE_NAME} WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }} AND traceId = ${{
+        type: TableColumnType.Text,
+        value: request.traceId,
+      }})`,
+    );
+  }
+
   private static appendCommonFilters(
     statement: Statement,
     request: Pick<

package/Server/Services/ProjectCallSMSConfigService.ts

@@ -17,6 +17,8 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import IncomingCallPolicyPhoneNumberService from "./IncomingCallPolicyPhoneNumberService";
 import IncomingCallPolicyPhoneNumber from "../../Models/DatabaseModels/IncomingCallPolicyPhoneNumber";
 import ModelPermission from "../Types/Database/Permissions/Index";
+import Query from "../Types/Database/Query";
+import PositiveNumber from "../../Types/PositiveNumber";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -27,10 +29,42 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeCreate(
     createBy: CreateBy<Model>,
   ): Promise<OnCreate<Model>> {
-    if (createBy.data.isProjectDefault && createBy.data.projectId) {
+    /*
+     * This hook can change the project's other configs (only one of them is
+     * the default), so it first makes sure the caller may create a config at
+     * all, as onBeforeDelete does for a delete. DatabaseService asks the same
+     * again before it saves; for a root caller this returns at once.
+     */
+    ModelPermission.checkCreatePermissions(
+      Model,
+      createBy.data,
+      createBy.props,
+    );
+
+    const projectId: ObjectID | undefined = createBy.data.projectId;
+
+    /*
+     * A project's first Twilio config becomes its default, so SMS and calls
+     * to the project's members go through it as soon as it is saved: adding
+     * your own Twilio account is asking for exactly that, and a config that
+     * nothing uses until someone finds a switch is a trap. Only when the
+     * caller leaves the choice out - an explicit false (the dashboard's
+     * switch turned off, an API call, Terraform, which always sends one) is
+     * kept. A project that already has a config keeps the one it uses.
+     */
+    if (
+      projectId &&
+      !this.isProjectDefaultChoiceGiven(createBy.data.isProjectDefault)
+    ) {
+      if (await this.isFirstConfigOfProject(projectId)) {
+        createBy.data.isProjectDefault = true;
+      }
+    }
+
+    if (createBy.data.isProjectDefault && projectId) {
       await this.updateBy({
         query: {
-          projectId: createBy.data.projectId,
+          projectId: projectId,
           isProjectDefault: true,
         },
         data: {
@@ -47,13 +81,52 @@ export class Service extends DatabaseService<Model> {
     return { createBy, carryForward: [] };
   }
 
+  /*
+   * Whether a create says whether the config is the project default. Null
+   * says nothing either: DatabaseService stores the column default for it.
+   */
+  private isProjectDefaultChoiceGiven(
+    isProjectDefault: boolean | null | undefined,
+  ): boolean {
+    return isProjectDefault !== undefined && isProjectDefault !== null;
+  }
+
+  // Whether the project has no Twilio config yet, so this one is its first.
+  private async isFirstConfigOfProject(projectId: ObjectID): Promise<boolean> {
+    const configCount: PositiveNumber = await this.countBy({
+      query: {
+        projectId: projectId,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return configCount.toNumber() === 0;
+  }
+
   @CaptureSpan()
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<Model>,
   ): Promise<OnUpdate<Model>> {
     if (updateBy.data.isProjectDefault === true) {
+      /*
+       * Making one config the default takes it from the others in its
+       * project, so the rows are looked up through what the caller may
+       * update, before anything else is read or changed. DatabaseService
+       * scopes the update itself the same way afterwards; for a root caller
+       * the query comes back as it is.
+       */
+      const updatableQuery: Query<Model> =
+        await ModelPermission.checkUpdateQueryPermissions(
+          Model,
+          updateBy.query,
+          updateBy.data,
+          updateBy.props,
+        );
+
       const itemsToUpdate: Array<Model> = await this.findBy({
-        query: updateBy.query,
+        query: updatableQuery,
         select: {
           _id: true,
           projectId: true,

package/Server/Services/ProjectOidcService.ts

@@ -1,10 +1,30 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/ProjectOidc";
+import { fillOidcProviderDefaults } from "../../Types/SSO/OidcProviderDefaults";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate } from "../Types/Database/Hooks";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  /*
+   * A provider created without a discovery URL, scopes, claim names or a
+   * description gets the usual ones (Types/SSO/OidcProviderDefaults), before
+   * the required-field check runs: the columns stay required, so the API and
+   * Terraform keep their contract, and a caller may leave them out. What the
+   * caller sent is kept.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    fillOidcProviderDefaults(createBy.data);
+
+    return { createBy, carryForward: null };
+  }
 }
 
 export default new Service();

package/Server/Services/ProjectSsoService.ts

@@ -1,10 +1,30 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/ProjectSso";
+import { fillSamlProviderDefaults } from "../../Types/SSO/SamlProviderDefaults";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate } from "../Types/Database/Hooks";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  /*
+   * A SAML provider created without a signature method, a digest method or
+   * a description gets the usual ones (Types/SSO/SamlProviderDefaults),
+   * before the required-field check runs: the columns stay required, so the
+   * API and Terraform keep their contract, and a caller may leave them out.
+   * What the caller sent is kept.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    fillSamlProviderDefaults(createBy.data);
+
+    return { createBy, carryForward: null };
+  }
 }
 
 export default new Service();

package/Server/Services/ProxmoxClusterService.ts

@@ -20,6 +20,10 @@ import { JSONObject } from "../../Types/JSON";
 import URL from "../../Types/API/URL";
 import DatabaseConfig from "../DatabaseConfig";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import DiscoveredResourceUpdate, {
+  MatchColumn,
+  matchedOnName,
+} from "../Utils/Telemetry/DiscoveredResourceUpdate";
 import ResourceHeartbeat from "../Utils/Telemetry/ResourceHeartbeat";
 import ObjectID from "../../Types/ObjectID";
 import QueryHelper from "../Types/Database/QueryHelper";
@@ -35,11 +39,32 @@ const LAST_SEEN_THROTTLE_SECONDS: number = 60;
 const LABELS_APPLIED_CACHE_NAMESPACE: string = "proxmox-cluster-labels-applied";
 const LABELS_APPLIED_CACHE_TTL_SECONDS: number = 60;
 
+/*
+ * A Proxmox cluster is matched to its telemetry by its name (proxmox.cluster.name),
+ * so a rename is held to the rules a new Proxmox cluster is: no spaces around
+ * it, never blank, and never another Proxmox cluster's name
+ * (DiscoveredResourceUpdate).
+ */
+const PROXMOX_CLUSTER_MATCH_COLUMN: MatchColumn = matchedOnName({
+  resourceName: "Proxmox cluster",
+});
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
 
+  @CaptureSpan()
+  protected override async onBeforeUpdateUniqueCheck(
+    updateBy: UpdateBy<Model>,
+  ): Promise<void> {
+    await DiscoveredResourceUpdate.checkMatchColumn({
+      service: this,
+      updateBy,
+      matchColumn: PROXMOX_CLUSTER_MATCH_COLUMN,
+    });
+  }
+
   @CaptureSpan()
   protected override async onCreateSuccess(
     onCreate: OnCreate<Model>,

package/Server/Services/RumApplicationService.ts

@@ -12,6 +12,11 @@ import SessionReplayGateCacheStore from "../Utils/SessionReplay/SessionReplayGat
 import logger, { LogAttributes } from "../Utils/Logger";
 import crypto from "crypto";
 import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import DiscoveredResourceCreate, {
+  DiscoveredResourceNaming,
+  namedAfterIdentity,
+} from "../Utils/Telemetry/DiscoveredResourceCreate";
 import RumApplicationLabelRuleEngineService from "./RumApplicationLabelRuleEngineService";
 import RumApplicationOwnerRuleEngineService from "./RumApplicationOwnerRuleEngineService";
 
@@ -29,11 +34,51 @@ const REPLAY_BUDGET_EXCEEDED_CACHE_NAMESPACE: string =
   "rum-application-replay-budget-exceeded";
 const REPLAY_BUDGET_EXCEEDED_THROTTLE_SECONDS: number = 300;
 
+/*
+ * An application is matched to its telemetry by the service.name its
+ * browser or mobile SDK reports, and named after it unless somebody gives
+ * it a display name of their own (DiscoveredResourceCreate).
+ */
+const RUM_APPLICATION_NAMING: DiscoveredResourceNaming<Model> =
+  namedAfterIdentity<Model>({
+    identityColumn: "appIdentifier",
+    resourceName: "RUM application",
+    identityName: "app name",
+  });
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
 
+  // Named after its app name when nobody gave it a name.
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    DiscoveredResourceCreate.fillName({
+      createBy,
+      naming: RUM_APPLICATION_NAMING,
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  /*
+   * An application that is already there - discovered from its telemetry or
+   * added before - is refused by its app name, not as a clash of names.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreateUniqueCheck(
+    createBy: CreateBy<Model>,
+  ): Promise<void> {
+    await DiscoveredResourceCreate.refuseClash({
+      service: this,
+      createBy,
+      naming: RUM_APPLICATION_NAMING,
+    });
+  }
+
   @CaptureSpan()
   protected override async onCreateSuccess(
     _onCreate: OnCreate<Model>,

package/Server/Services/ScheduledMaintenanceService.ts

@@ -58,7 +58,7 @@ import MailService from "../../Server/Services/MailService";
 import ProjectCallSMSConfigService from "../../Server/Services/ProjectCallSMSConfigService";
 import ProjectSmtpConfigService from "../../Server/Services/ProjectSmtpConfigService";
 import SmsService from "../../Server/Services/SmsService";
-import StatusPageResourceService from "../../Server/Services/StatusPageResourceService";
+import AffectedStatusPageResources from "../Utils/StatusPage/AffectedStatusPageResources";
 import StatusPageService from "../../Server/Services/StatusPageService";
 import StatusPageSubscriberService from "../../Server/Services/StatusPageSubscriberService";
 import StatusPageSubscriberUnsubscribe from "../../Types/StatusPage/StatusPageSubscriberUnsubscribe";
@@ -200,34 +200,20 @@ export class Service extends DatabaseService<Model> {
         } as LogAttributes,
       );
 
-      let statusPageResources: Array<StatusPageResource> = [];
-
-      if (event.monitors && event.monitors.length > 0) {
-        statusPageResources = await StatusPageResourceService.findByMonitors({
-          monitors: event.monitors,
+      /*
+       * The resources the event affects on each status page: its monitors,
+       * and the monitor groups that hold them.
+       */
+      const statusPageToResources: Dictionary<Array<StatusPageResource>> =
+        await AffectedStatusPageResources.findForMonitors({
+          monitors: event.monitors || [],
+          statusPages: event.statusPages || [],
           select: {
             _id: true,
             displayName: true,
             statusPageId: true,
           },
         });
-      }
-
-      const statusPageToResources: Dictionary<Array<StatusPageResource>> = {};
-
-      for (const resource of statusPageResources) {
-        if (!resource.statusPageId) {
-          continue;
-        }
-
-        if (!statusPageToResources[resource.statusPageId?.toString()]) {
-          statusPageToResources[resource.statusPageId?.toString()] = [];
-        }
-
-        statusPageToResources[resource.statusPageId?.toString()]?.push(
-          resource,
-        );
-      }
 
       const statusPages: Array<StatusPage> =
         await StatusPageSubscriberService.getStatusPagesToSendNotification(

package/Server/Services/ServerlessFunctionService.ts

@@ -11,6 +11,11 @@ import GlobalCache from "../Infrastructure/GlobalCache";
 import logger, { LogAttributes } from "../Utils/Logger";
 import crypto from "crypto";
 import { OnCreate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import DiscoveredResourceCreate, {
+  DiscoveredResourceNaming,
+  namedAfterIdentity,
+} from "../Utils/Telemetry/DiscoveredResourceCreate";
 import ServerlessFunctionLabelRuleEngineService from "./ServerlessFunctionLabelRuleEngineService";
 import ServerlessFunctionOwnerRuleEngineService from "./ServerlessFunctionOwnerRuleEngineService";
 
@@ -21,11 +26,53 @@ const LABELS_APPLIED_CACHE_NAMESPACE: string =
   "serverless-function-labels-applied";
 const LABELS_APPLIED_CACHE_TTL_SECONDS: number = 60;
 
+/*
+ * A function is matched to its telemetry by faas.name - which ingest fills in
+ * from service.name on a serverless platform that sets none (Azure
+ * Functions) - and named after it unless somebody gives it a display name
+ * of their own (DiscoveredResourceCreate).
+ */
+const SERVERLESS_FUNCTION_NAMING: DiscoveredResourceNaming<Model> =
+  namedAfterIdentity<Model>({
+    identityColumn: "functionIdentifier",
+    resourceName: "serverless function",
+    identityName: "function name",
+  });
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
 
+  // Named after its function name when nobody gave it a name.
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    DiscoveredResourceCreate.fillName({
+      createBy,
+      naming: SERVERLESS_FUNCTION_NAMING,
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  /*
+   * A function that is already there - discovered from its telemetry or
+   * added before - is refused by its function name, not as a clash of
+   * names.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreateUniqueCheck(
+    createBy: CreateBy<Model>,
+  ): Promise<void> {
+    await DiscoveredResourceCreate.refuseClash({
+      service: this,
+      createBy,
+      naming: SERVERLESS_FUNCTION_NAMING,
+    });
+  }
+
   @CaptureSpan()
   protected override async onCreateSuccess(
     _onCreate: OnCreate<Model>,