@oneuptime/common 12.0.22 → 12.0.24

package/Server/Services/NetworkDeviceAutoImportRuleService.ts

@@ -0,0 +1,181 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/NetworkDeviceAutoImportRule";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import BadDataException from "../../Types/Exception/BadDataException";
+import RulePatternMatchUtil from "../../Utils/Rules/RulePatternMatchUtil";
+import ScanTargetUtil from "../../Utils/NetworkDiscovery/ScanTargetUtil";
+
+/*
+ * Write-time validation for auto-import rules, following the
+ * NetworkSiteAssignmentRuleService contract: a condition that can only ever
+ * match nothing is rejected where the user can see it, not logged about by
+ * the engine long after they left the form.
+ */
+
+/*
+ * What a sysObjectID condition may contain: an optional leading dot, then
+ * digits, dots and '*' wildcards. Hoisted so the literal is not the object
+ * of a member expression, which `wrap-regex` and Prettier cannot agree on —
+ * same reason as CidrMatchUtil.
+ */
+const OID_PATTERN_SHAPE: RegExp = /^\.?[\d.*]+$/;
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    this.validateCriteria({
+      ipMatchTarget: createBy.data.ipMatchTarget,
+      sysNamePattern: createBy.data.sysNamePattern,
+      sysDescrPattern: createBy.data.sysDescrPattern,
+      sysObjectIdPattern: createBy.data.sysObjectIdPattern,
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    const dataKeys: Array<string> = Object.keys(updateBy.data || {});
+
+    const isCriteriaChange: boolean =
+      dataKeys.includes("ipMatchTarget") ||
+      dataKeys.includes("sysNamePattern") ||
+      dataKeys.includes("sysDescrPattern") ||
+      dataKeys.includes("sysObjectIdPattern");
+
+    if (!isCriteriaChange) {
+      return { updateBy, carryForward: null };
+    }
+
+    /*
+     * The update may clear one criterion while another only exists on the
+     * stored row, so validate the RESULTING state of every matched row.
+     */
+    const existingRules: Array<Model> = await this.findBy({
+      query: updateBy.query,
+      select: {
+        _id: true,
+        ipMatchTarget: true,
+        sysNamePattern: true,
+        sysDescrPattern: true,
+        sysObjectIdPattern: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const data: Record<string, unknown> = updateBy.data as unknown as Record<
+      string,
+      unknown
+    >;
+
+    for (const existingRule of existingRules) {
+      this.validateCriteria({
+        ipMatchTarget: dataKeys.includes("ipMatchTarget")
+          ? (data["ipMatchTarget"] as string | null)
+          : existingRule.ipMatchTarget,
+        sysNamePattern: dataKeys.includes("sysNamePattern")
+          ? (data["sysNamePattern"] as string | null)
+          : existingRule.sysNamePattern,
+        sysDescrPattern: dataKeys.includes("sysDescrPattern")
+          ? (data["sysDescrPattern"] as string | null)
+          : existingRule.sysDescrPattern,
+        sysObjectIdPattern: dataKeys.includes("sysObjectIdPattern")
+          ? (data["sysObjectIdPattern"] as string | null)
+          : existingRule.sysObjectIdPattern,
+      });
+    }
+
+    return { updateBy, carryForward: null };
+  }
+
+  private validateCriteria(data: {
+    ipMatchTarget?: string | null | undefined;
+    sysNamePattern?: string | null | undefined;
+    sysDescrPattern?: string | null | undefined;
+    sysObjectIdPattern?: string | null | undefined;
+  }): void {
+    const ipMatchTarget: string = (data.ipMatchTarget || "").trim();
+    const sysNamePattern: string = (data.sysNamePattern || "").trim();
+    const sysDescrPattern: string = (data.sysDescrPattern || "").trim();
+    const sysObjectIdPattern: string = (data.sysObjectIdPattern || "").trim();
+
+    /*
+     * A rule with no conditions matches nothing (see AutoImportRuleMatcher) —
+     * and would read as "match everything" to whoever finds it later.
+     */
+    if (
+      !ipMatchTarget &&
+      !sysNamePattern &&
+      !sysDescrPattern &&
+      !sysObjectIdPattern
+    ) {
+      throw new BadDataException(
+        "At least one of Host IP Is In, System Name Pattern, System Description Pattern, or System Object ID Pattern is required.",
+      );
+    }
+
+    /*
+     * Well-formedness only, deliberately NOT the scan-size ceiling: matching
+     * an address against 10.0.0.0/8 is a containment check, not a sweep, so
+     * a condition covering a huge block is legitimate here even though a
+     * scan target that size is not.
+     */
+    if (ipMatchTarget && !ScanTargetUtil.isValid(ipMatchTarget)) {
+      throw new BadDataException(
+        `"${ipMatchTarget}" is not a valid Host IP condition. ${ScanTargetUtil.getSyntaxHint()}`,
+      );
+    }
+
+    this.validatePattern("System Name Pattern", sysNamePattern);
+    this.validatePattern("System Description Pattern", sysDescrPattern);
+    this.validateOidPattern(sysObjectIdPattern);
+  }
+
+  private validatePattern(title: string, pattern: string): void {
+    if (!pattern || RulePatternMatchUtil.isSupportedPattern(pattern)) {
+      return;
+    }
+
+    throw new BadDataException(
+      `${title} is neither a valid regular expression nor a '*' wildcard pattern, so it would never match: ${pattern}`,
+    );
+  }
+
+  /*
+   * The sysObjectID condition is NOT free-text: an OID is a dotted numeric
+   * arc, matched as a literal-dot '*' glob or an arc prefix (see
+   * AutoImportRuleMatcher.matchesOidPattern — regex-first matching would make
+   * "1.3.6.1.4.1.9.*" match enterprise 94 too). So the only characters that
+   * can ever match anything are digits, dots and '*'; anything else is a
+   * pattern that silently never fires, which is exactly what this service
+   * exists to reject at the write.
+   */
+  private validateOidPattern(pattern: string): void {
+    if (!pattern) {
+      return;
+    }
+
+    if (!OID_PATTERN_SHAPE.test(pattern)) {
+      throw new BadDataException(
+        `System Object ID Pattern must be an OID prefix (1.3.6.1.4.1.9) or a '*' wildcard OID pattern (1.3.6.1.4.1.9.*) — digits, dots and '*' only: ${pattern}`,
+      );
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/NetworkDeviceDiscoveryScanService.ts

@@ -6,6 +6,7 @@ import UpdateBy from "../Types/Database/UpdateBy";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ScanTargetUtil from "../../Utils/NetworkDiscovery/ScanTargetUtil";
+import ScanNameUtil from "../../Utils/NetworkDiscovery/ScanNameUtil";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -33,6 +34,25 @@ export class Service extends DatabaseService<Model> {
   ): Promise<OnCreate<Model>> {
     this.validateScanTarget(createBy.data.cidr);
 
+    /*
+     * The name is normalized as well as validated — collapsed onto one line,
+     * trimmed, and a blank one dropped entirely — so the column holds either a
+     * name or nothing. An empty string stored here would read as a name to
+     * every `scan.name ?` in the product and render as a blank line above the
+     * scan target. See ScanNameUtil.
+     */
+    this.validateScanName(createBy.data.name);
+
+    /*
+     * Written through a cast because `exactOptionalPropertyTypes` forbids
+     * assigning `undefined` to an optional property — and dropping a blank
+     * name is exactly that assignment. Undefined rather than null: a model
+     * instance starts with every column undefined, so this leaves the row in
+     * the state a scan created without a name would already have been in.
+     */
+    (createBy.data as unknown as Record<string, unknown>)["name"] =
+      ScanNameUtil.normalize(createBy.data.name) ?? undefined;
+
     return { createBy, carryForward: null };
   }
 
@@ -54,6 +74,27 @@ export class Service extends DatabaseService<Model> {
       );
     }
 
+    /*
+     * The name IS user-updatable — renaming a scan is the whole point of
+     * letting it be named — so this path is the one the form actually takes,
+     * not just a guard against root writers.
+     *
+     * Cleared with null rather than left as "": the form sends back an empty
+     * box as an empty string, and the operator who emptied it meant "this scan
+     * has no name", which is what NULL says. `undefined` would not do — the
+     * key is present in the update, and an undefined value is a column TypeORM
+     * would try to write.
+     */
+    if (dataKeys.includes("name")) {
+      const data: Record<string, unknown> = updateBy.data as Record<
+        string,
+        unknown
+      >;
+
+      this.validateScanName(data["name"]);
+      data["name"] = ScanNameUtil.normalize(data["name"]);
+    }
+
     return { updateBy, carryForward: null };
   }
 
@@ -75,6 +116,24 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException(validationError);
     }
   }
+
+  /*
+   * Same contract as validateScanTarget above: the value is passed through
+   * untouched, because it arrives straight from the request JSON and may be a
+   * number, an object or an array rather than a string. ScanNameUtil type-
+   * guards internally and reports a non-string as such.
+   *
+   * An ABSENT or blank name is not an error — the column is optional, and a
+   * scan with no name reads as it always did, by its target.
+   */
+  private validateScanName(name: unknown): void {
+    const validationError: string | null =
+      ScanNameUtil.getValidationError(name);
+
+    if (validationError) {
+      throw new BadDataException(validationError);
+    }
+  }
 }
 
 export default new Service();

package/Server/Services/NetworkDeviceService.ts

@@ -303,6 +303,24 @@ export class Service extends DatabaseService<Model> {
             await this.applySiteAssignmentRulesToDevice(createdItem.id!);
           }
         })
+        .then(async () => {
+          /*
+           * A device created monitor-backed adopts its monitor's CURRENT
+           * status right away rather than waiting for that monitor's next
+           * status CHANGE. Skipped for SNMP devices, which are judged by
+           * their own walk.
+           */
+          if (
+            NetworkDeviceMonitoringMethodUtil.isMonitorBacked(
+              createdItem.monitoringMethod,
+            )
+          ) {
+            await this.refreshStampedMonitorStatus({
+              deviceId: createdItem.id!,
+              clearWhenNotMonitorBacked: false,
+            });
+          }
+        })
         .catch((error: Error) => {
           logger.error(
             `Error applying network device rules in NetworkDeviceService.onCreateSuccess: ${error}`,
@@ -453,6 +471,109 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
+  /*
+   * Re-derives one device's stamped `currentMonitorStatusId` from its
+   * binding, and refreshes its site chain if the stamp moved.
+   *
+   * The stamp is what every monitor-backed surface reads — the device list
+   * pill, the site rollup, the topology node — and until this existed the
+   * ONLY thing that ever wrote it was
+   * `NetworkSiteService.onMonitorStatusChanged`, which fires on a monitor's
+   * next status CHANGE. Bind a device to a Ping monitor that is already Up
+   * and staying Up and nothing writes the stamp at all, so the device sits
+   * on "Pending" until the monitor happens to go down — which is
+   * OneUptime/oneuptime#3392. Binding is itself an event that decides the
+   * device's status, so it stamps here.
+   *
+   * `clearWhenNotMonitorBacked` is for the write that moves a device OFF
+   * monitor-backed: the ping monitor's verdict must not outlive the binding
+   * (DeviceHealthStateUtil lets a stamped status beat reachability, so a
+   * stale one would poison the site rollup of a device that is now walked).
+   * It is deliberately NOT set when a write only touches the monitor
+   * binding of an SNMP device, because an SNMP device's stamp comes from
+   * the Network Device monitor that watches it, and that binding lives in
+   * the monitor's step data rather than in this column.
+   */
+  @CaptureSpan()
+  public async refreshStampedMonitorStatus(data: {
+    deviceId: ObjectID;
+    clearWhenNotMonitorBacked: boolean;
+  }): Promise<void> {
+    const device: Model | null = await this.findOneById({
+      id: data.deviceId,
+      select: {
+        _id: true,
+        projectId: true,
+        siteId: true,
+        monitoringMethod: true,
+        monitorId: true,
+        currentMonitorStatusId: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!device || !device.projectId) {
+      return;
+    }
+
+    const isMonitorBacked: boolean =
+      NetworkDeviceMonitoringMethodUtil.isMonitorBacked(
+        device.monitoringMethod,
+      );
+
+    if (!isMonitorBacked && !data.clearWhenNotMonitorBacked) {
+      return;
+    }
+
+    let monitorStatusId: ObjectID | null = null;
+
+    if (isMonitorBacked && device.monitorId) {
+      /*
+       * Scoped to the device's project on the read as well as on the write
+       * path in onBeforeCreate/onBeforeUpdate: a monitor from another
+       * tenant must never be able to stamp a status here.
+       */
+      const monitor: Monitor | null = await MonitorService.findOneBy({
+        query: {
+          _id: device.monitorId,
+          projectId: device.projectId,
+        },
+        select: {
+          _id: true,
+          currentMonitorStatusId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      monitorStatusId = monitor?.currentMonitorStatusId || null;
+    }
+
+    const currentStampId: string | null =
+      device.currentMonitorStatusId?.toString() || null;
+    const nextStampId: string | null = monitorStatusId?.toString() || null;
+
+    if (currentStampId === nextStampId) {
+      return;
+    }
+
+    await this.updateColumnsByIdWithoutHooks({
+      id: data.deviceId,
+      data: {
+        currentMonitorStatusId: monitorStatusId,
+      },
+    });
+
+    if (device.siteId) {
+      await NetworkSiteService.recomputeRollupForSiteAndAncestors(
+        device.siteId,
+      );
+    }
+  }
+
   /*
    * Site maintenance after device updates. Resilient by design: a rollup
    * or rule-engine failure must never fail the device update itself.
@@ -462,6 +583,33 @@ export class Service extends DatabaseService<Model> {
     onUpdate: OnUpdate<Model>,
     updatedItemIds: Array<ObjectID>,
   ): Promise<OnUpdate<Model>> {
+    /*
+     * Re-stamp before the site maintenance below, and in its own try: the
+     * two are independent, and a rollup failure must not cost the device
+     * its status (nor the other way round).
+     */
+    try {
+      const dataKeys: Array<string> = Object.keys(onUpdate.updateBy.data || {});
+      const isMethodWrite: boolean = dataKeys.includes("monitoringMethod");
+      const isMonitorWrite: boolean = RelationIdUtil.isWritten(
+        dataKeys,
+        MONITOR_KEYS,
+      );
+
+      if (isMethodWrite || isMonitorWrite) {
+        for (const deviceId of updatedItemIds) {
+          await this.refreshStampedMonitorStatus({
+            deviceId: deviceId,
+            clearWhenNotMonitorBacked: isMethodWrite,
+          });
+        }
+      }
+    } catch (error) {
+      logger.error(
+        `Error in NetworkDeviceService.onUpdateSuccess monitor status refresh: ${error}`,
+      );
+    }
+
     try {
       const dataKeys: Array<string> = Object.keys(onUpdate.updateBy.data || {});
 

package/Server/Services/OnCallDutyPolicyEscalationRuleScheduleService.ts

@@ -31,6 +31,48 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
+  /**
+   * Re-resolve and persist the schedule's roster after it is attached to, or
+   * detached from, an on-call policy.
+   *
+   * The persisted roster columns are derived state, and one of their inputs is
+   * WHICH policies escalate to the schedule: a schedule attached to exactly one
+   * policy is resolved in that policy's context, so its policy-scoped user
+   * overrides count, and a schedule attached to none or to several is resolved
+   * policy-blind (OnCallDutyPolicyScheduleService.getSingleAttachedPolicyId).
+   * Attaching or detaching therefore changes the correct answer, and every other
+   * input — layers, layer users, overrides — already refreshes on change.
+   *
+   * Without this the roster stayed on the pre-attach answer until the next
+   * natural hand-off, so the schedule page's "X is currently on the roster"
+   * banner and the "On Call Now" column named the originally-scheduled user for
+   * the whole override window while alert routing paged the substitute.
+   * https://github.com/OneUptime/oneuptime/issues/3411
+   *
+   * Best-effort: an attach must not fail because a roster could not be
+   * recomputed, and the refresh is idempotent (an unaffected schedule simply
+   * resolves to the same roster and diffs to "no change", so no duplicate
+   * hand-off notification is sent).
+   */
+  private async refreshScheduleRoster(
+    onCallDutyPolicyScheduleId: ObjectID | null | undefined,
+  ): Promise<void> {
+    if (!onCallDutyPolicyScheduleId) {
+      return;
+    }
+
+    try {
+      await OnCallDutyPolicyScheduleService.refreshCurrentUserIdAndHandoffTimeInSchedule(
+        onCallDutyPolicyScheduleId,
+      );
+    } catch (err) {
+      logger.error(
+        "Error refreshing the roster after an on-call schedule was attached to or detached from a policy (best-effort).",
+      );
+      logger.error(err);
+    }
+  }
+
   protected override async onCreateSuccess(
     _onCreate: OnCreate<Model>,
     createdItem: Model,
@@ -75,6 +117,12 @@ export class Service extends DatabaseService<Model> {
       );
     }
 
+    /*
+     * Bring the persisted roster in line with the new policy attachment before
+     * anything below can return early. See refreshScheduleRoster.
+     */
+    await this.refreshScheduleRoster(createdModel.onCallDutyPolicyScheduleId);
+
     // send notification to the new current user.
 
     const userOnSchedule: ObjectID | null =
@@ -324,6 +372,23 @@ export class Service extends DatabaseService<Model> {
   ): Promise<OnDelete<Model>> {
     const deletedItems: Array<Model> = onDelete.carryForward.deletedItems;
 
+    /*
+     * Detaching changes the schedule's policy context just as attaching does, so
+     * its roster has to be re-resolved here too. Deduped by schedule: removing a
+     * schedule from several escalation rules of one policy is one context
+     * change, not several. See refreshScheduleRoster.
+     */
+    const refreshedScheduleIds: Set<string> = new Set<string>();
+    for (const deletedItem of deletedItems) {
+      const scheduleId: string | undefined =
+        deletedItem.onCallDutyPolicyScheduleId?.toString();
+      if (!scheduleId || refreshedScheduleIds.has(scheduleId)) {
+        continue;
+      }
+      refreshedScheduleIds.add(scheduleId);
+      await this.refreshScheduleRoster(deletedItem.onCallDutyPolicyScheduleId);
+    }
+
     for (const deletedItem of deletedItems) {
       const userOnSchedule: ObjectID | null =
         await OnCallDutyPolicyScheduleService.getCurrentUserIdInSchedule(

package/Server/Services/OnCallDutyPolicyFeedService.ts

@@ -19,7 +19,7 @@ export class Service extends DatabaseService<OnCallDutyPolicyFeed> {
     super(OnCallDutyPolicyFeed);
 
     if (IsBillingEnabled) {
-      this.hardDeleteItemsOlderThanInDays("createdAt", 90);
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365); // 3 years
     }
   }
 

package/Server/Services/ProjectService.ts

@@ -16,8 +16,14 @@ import UpdateBy from "../Types/Database/UpdateBy";
 import logger, { LogAttributes } from "../Utils/Logger";
 import Errors from "../Utils/Errors";
 import ProductAnalytics from "../Utils/ProductAnalytics";
-import MarketingEventUtil from "../Utils/Marketing/MarketingEventUtil";
+import MarketingEventUtil, {
+  utmAnalyticsProperties,
+} from "../Utils/Marketing/MarketingEventUtil";
 import { MarketingEventType } from "../../Types/Marketing/MarketingEvent";
+import {
+  UtmPropertyKeys,
+  UtmUrlPropertyKey,
+} from "../../Types/Marketing/Attribution";
 import SessionReplayGateCacheStore from "../Utils/SessionReplay/SessionReplayGateCacheStore";
 import AccessTokenService from "./AccessTokenService";
 import BillingService from "./BillingService";
@@ -198,6 +204,10 @@ export class ProjectService extends DatabaseService<Model> {
         utmMedium: true,
         utmTerm: true,
         utmContent: true,
+        utmId: true,
+        utmSourcePlatform: true,
+        utmCreativeFormat: true,
+        utmMarketingTactic: true,
         utmUrl: true,
         clickIds: true,
         firstTouchAttribution: true,
@@ -348,13 +358,17 @@ export class ProjectService extends DatabaseService<Model> {
     data.data.createdOwnerPhone = user.companyPhoneNumber!;
     data.data.createdOwnerCompanyName = user.companyName!;
 
-    // UTM info.
-    data.data.utmCampaign = user.utmCampaign!;
-    data.data.utmSource = user.utmSource!;
-    data.data.utmMedium = user.utmMedium!;
-    data.data.utmTerm = user.utmTerm!;
-    data.data.utmContent = user.utmContent!;
-    data.data.utmUrl = user.utmUrl!;
+    /*
+     * UTM info, copied field by field off the shared contract rather than
+     * hand-listed. Hand-listing is how Project ended up with four columns
+     * (utmId and its GA4 siblings) that the schema had but nothing ever wrote.
+     */
+    const projectRow: JSONObject = data.data as unknown as JSONObject;
+    const userRow: JSONObject = user as unknown as JSONObject;
+
+    for (const propertyKey of [...UtmPropertyKeys, UtmUrlPropertyKey]) {
+      projectRow[propertyKey] = userRow[propertyKey];
+    }
 
     // Ad attribution info (click IDs + first touch).
     data.data.clickIds = user.clickIds!;
@@ -572,6 +586,10 @@ export class ProjectService extends DatabaseService<Model> {
         utmCampaign: true,
         utmTerm: true,
         utmContent: true,
+        utmId: true,
+        utmSourcePlatform: true,
+        utmCreativeFormat: true,
+        utmMarketingTactic: true,
         utmUrl: true,
         clickIds: true,
         firstTouchAttribution: true,
@@ -950,11 +968,7 @@ These are no longer recorded against the project and have to be cancelled by han
        */
       is_paid_conversion: true,
       has_custom_pricing: data.plan.isCustomPricing(),
-      utm_source: data.project.utmSource || "",
-      utm_medium: data.project.utmMedium || "",
-      utm_campaign: data.project.utmCampaign || "",
-      utm_term: data.project.utmTerm || "",
-      utm_content: data.project.utmContent || "",
+      ...utmAnalyticsProperties(data.project as unknown as JSONObject),
       click_ids: data.project.clickIds || {},
     };
 
@@ -1065,9 +1079,7 @@ These are no longer recorded against the project and have to be cancelled by han
         oldPlanOrder !== null && newPlanOrder === oldPlanOrder,
       is_paid_conversion: oldMonthlyAmountInUSD === 0 && newPlanIsPaid,
       has_custom_pricing: data.newPlan.isCustomPricing(),
-      utm_source: data.project.utmSource || "",
-      utm_medium: data.project.utmMedium || "",
-      utm_campaign: data.project.utmCampaign || "",
+      ...utmAnalyticsProperties(data.project as unknown as JSONObject),
       click_ids: data.project.clickIds || {},
     };
 
@@ -1436,9 +1448,7 @@ These are no longer recorded against the project and have to be cancelled by han
           project_id: createdItem.id?.toString() || "",
           project_name: createdItem.name?.toString() || "",
           plan: createdItem.planName?.toString() || "",
-          utm_source: createdItem.utmSource || "",
-          utm_medium: createdItem.utmMedium || "",
-          utm_campaign: createdItem.utmCampaign || "",
+          ...utmAnalyticsProperties(createdItem as unknown as JSONObject),
           click_ids: createdItem.clickIds || {},
         },
       });