@oneuptime/common 12.0.10 → 12.0.11

package/Models/DatabaseModels/NetworkDevice.ts

@@ -646,6 +646,50 @@ export default class NetworkDevice extends BaseModel {
   })
   public monitoringMethod?: string = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.CreateNetworkDevice,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadNetworkDevice,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditNetworkDevice,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: true,
+    title: "Device Role",
+    description:
+      "What this device does on the network — router, switch, access point and so on. Left empty, the role is worked out from the device's own SNMP identity. Set it when there is no SNMP to read: a ping-only device has no identity to classify, and the role decides both the shape it is drawn with and where it sits in the topology hierarchy.",
+    example: "switch",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public deviceRole?: string = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/NetworkDeviceLink.ts

@@ -376,6 +376,122 @@ export default class NetworkDeviceLink extends BaseModel {
   })
   public toDeviceId?: ObjectID = undefined;
 
+  /*
+   * --- Which end is up ---
+   *
+   * A link says two devices are cabled together. It does not say which one
+   * the other hangs off, and the topology map has to decide: the
+   * parent-child view draws an actual tree, so somebody is the parent.
+   * Left to itself it infers one from device roles and connection counts,
+   * which is a good guess on a network that speaks SNMP and no guess at
+   * all on one that does not — the case issue #3192 is about, where the
+   * child is a ping-only device whose role nothing can classify.
+   *
+   * This column is the operator answering that question outright. It is
+   * NULL by default and on every row written before it existed, and NULL
+   * means exactly what the map did then: a peer link, direction inferred.
+   * So no existing map moves, and a hierarchy only becomes declared when
+   * somebody declares it.
+   *
+   * The value must be one of this link's own two ends — a parent that is
+   * not on the link is not a statement about the link — which the service
+   * enforces on create and on update, including when an update moves an
+   * end out from under a parent that was already set.
+   */
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.CreateNetworkDeviceLink,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadNetworkDeviceLink,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditNetworkDeviceLink,
+    ],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "parentDeviceId",
+    type: TableColumnType.Entity,
+    modelType: NetworkDevice,
+    title: "Parent Device",
+    description:
+      "Relation to whichever end of this link is the parent, if the hierarchy is declared rather than inferred",
+  })
+  @ManyToOne(
+    () => {
+      return NetworkDevice;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "parentDeviceId" })
+  public parentDevice?: NetworkDevice = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.CreateNetworkDeviceLink,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadNetworkDeviceLink,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditNetworkDeviceLink,
+    ],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "Parent Device ID",
+    description:
+      "ID of whichever end of this link is the parent. Must be the From Device or the To Device. Empty means the two are peers and the map infers the hierarchy.",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public parentDeviceId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Server/Infrastructure/Postgres/SchemaMigrations/1787400000000-AddDeviceRoleAndDeclaredLinkParent.ts

@@ -0,0 +1,52 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Two nullable columns, both of them an operator stating something the
+ * network cannot be asked:
+ *
+ *   NetworkDevice.deviceRole      — what this box actually is, for devices
+ *                                   with no SNMP identity to classify.
+ *   NetworkDeviceLink.parentDeviceId — which end of a declared link is up.
+ *
+ * Nullable on purpose, with no backfill. NULL is a meaningful value in
+ * both cases and it is the value every existing row should hold: no role
+ * override (so the classifier keeps deciding) and no declared hierarchy
+ * (so the map keeps inferring one). Defaulting either would silently
+ * restate every device and every link in every project as something an
+ * operator had chosen, which is the one thing neither column may mean.
+ */
+export class AddDeviceRoleAndDeclaredLinkParent1787400000000
+  implements MigrationInterface
+{
+  public name = "AddDeviceRoleAndDeclaredLinkParent1787400000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" ADD "deviceRole" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceLink" ADD "parentDeviceId" uuid`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_01752cd47b773df38b4a54ae53" ON "NetworkDeviceLink" ("parentDeviceId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceLink" ADD CONSTRAINT "FK_01752cd47b773df38b4a54ae539" FOREIGN KEY ("parentDeviceId") REFERENCES "NetworkDevice"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceLink" DROP CONSTRAINT "FK_01752cd47b773df38b4a54ae539"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_01752cd47b773df38b4a54ae53"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceLink" DROP COLUMN "parentDeviceId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" DROP COLUMN "deviceRole"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -527,6 +527,7 @@ import { AddOnCallNotificationFallbackColumns1787000000000 } from "./17870000000
 import { AddAIConversationPageContext1787100000000 } from "./1787100000000-AddAIConversationPageContext";
 import { AddAIChatMessageFeedback1787200000000 } from "./1787200000000-AddAIChatMessageFeedback";
 import { AddEpisodeMemberNotifyIndexes1787300000000 } from "./1787300000000-AddEpisodeMemberNotifyIndexes";
+import { AddDeviceRoleAndDeclaredLinkParent1787400000000 } from "./1787400000000-AddDeviceRoleAndDeclaredLinkParent";
 
 export default [
   InitialMigration,
@@ -1058,4 +1059,5 @@ export default [
   AddAIConversationPageContext1787100000000,
   AddAIChatMessageFeedback1787200000000,
   AddEpisodeMemberNotifyIndexes1787300000000,
+  AddDeviceRoleAndDeclaredLinkParent1787400000000,
 ];

package/Server/Services/NetworkDeviceLinkService.ts

@@ -2,24 +2,140 @@ 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 { 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 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";
+import Query from "../Types/Database/Query";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 
 // 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"];
+const PARENT_DEVICE_KEYS: Array<string> = ["parentDeviceId", "parentDevice"];
+
+/*
+ * A device id, compared the way Postgres compares it.
+ *
+ * These columns are `uuid`. Postgres normalises and matches them without
+ * regard to case, and ObjectID.isValidUUID accepts either case, so an API
+ * client may legitimately send `AAAAAAAA-...` for a row stored as
+ * `aaaaaaaa-...`. A raw JS !== between the two says "different device" and
+ * refuses a parent that is in fact an end of the link. Note that the
+ * device-existence check below cannot disagree: it runs in Postgres.
+ */
+const sameDeviceId: (a: ObjectID, b: ObjectID) => boolean = (
+  a: ObjectID,
+  b: ObjectID,
+): boolean => {
+  return a.toString().toLowerCase() === b.toString().toLowerCase();
+};
+
+/*
+ * A declared parent has to be one of the two devices the link connects.
+ * Anything else is not a statement about this link at all, and the map
+ * would silently ignore it — the operator would have declared a hierarchy
+ * and watched nothing change.
+ */
+const assertParentIsAnEnd: (
+  parentDeviceId: ObjectID | null,
+  fromDeviceId: ObjectID,
+  toDeviceId: ObjectID,
+) => void = (
+  parentDeviceId: ObjectID | null,
+  fromDeviceId: ObjectID,
+  toDeviceId: ObjectID,
+): void => {
+  if (!parentDeviceId) {
+    return;
+  }
+  if (
+    !sameDeviceId(parentDeviceId, fromDeviceId) &&
+    !sameDeviceId(parentDeviceId, toDeviceId)
+  ) {
+    throw new BadDataException(
+      "The parent device must be one of the two devices this link connects.",
+    );
+  }
+};
+
+/*
+ * Which of `keys` the payload actually WRITES.
+ *
+ * Not the same question as which keys are present. TypeORM drops
+ * undefined-valued keys before it builds the SET list — "it doesn't make
+ * sense to update undefined properties" — so a key holding undefined
+ * changes nothing in the database. Treating it as a write makes this hook
+ * validate a row that is never going to exist: model the parent as
+ * cleared, accept the write, and leave the stored parent stranded on a
+ * link whose end just moved. Null and "" are different and really do
+ * clear the column, which is why the test is against undefined alone.
+ */
+const writtenKeys: (
+  data: Record<string, unknown>,
+  keys: Array<string>,
+) => Array<string> = (
+  data: Record<string, unknown>,
+  keys: Array<string>,
+): Array<string> => {
+  return keys.filter((key: string) => {
+    return key in data && data[key] !== undefined;
+  });
+};
+
+/*
+ * An update payload is a QueryDeepPartialEntity, so a column may hold a
+ * raw SQL-expression function instead of a value. RelationIdUtil reads one
+ * as null — indistinguishable from "cleared" — and the whole invariant is
+ * then checked against a row that bears no relation to what will be
+ * written. Nothing in the tree writes this model that way today; refusing
+ * is what keeps that true, and a caller who needs it can resolve the id
+ * before calling rather than have it silently mis-validated.
+ */
+const assertNoSqlExpression: (
+  data: Record<string, unknown>,
+  keys: Array<string>,
+) => void = (data: Record<string, unknown>, keys: Array<string>): void => {
+  for (const key of keys) {
+    if (typeof data[key] === "function") {
+      throw new BadDataException(
+        `${key} cannot be set to a raw SQL expression on a network device link — the link's ends and its declared parent have to be checked against each other, which needs actual ids.`,
+      );
+    }
+  }
+};
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
 
+  /*
+   * onBeforeUpdate runs before DatabaseService permission-checks the query,
+   * so reading the raw client query as root would hand the hook rows from
+   * other projects. Re-apply the caller's tenant here. (Same helper as
+   * NetworkDeviceService and NetworkSiteService — private per service,
+   * which is the shape the codebase already settled on.)
+   */
+  private scopeQueryToCallerTenant(
+    query: Query<Model>,
+    props: DatabaseCommonInteractionProps,
+  ): Query<Model> {
+    if (props.isRoot || !props.tenantId) {
+      return query;
+    }
+
+    return {
+      ...query,
+      projectId: props.tenantId,
+    };
+  }
+
   /*
    * Two guards, both about links that would be nonsense on the map:
    *
@@ -39,6 +155,12 @@ export class Service extends DatabaseService<Model> {
       unknown
     >;
 
+    assertNoSqlExpression(data, [
+      ...FROM_DEVICE_KEYS,
+      ...TO_DEVICE_KEYS,
+      ...PARENT_DEVICE_KEYS,
+    ]);
+
     const fromDeviceId: ObjectID | null = RelationIdUtil.read(
       data,
       FROM_DEVICE_KEYS,
@@ -52,7 +174,7 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("A link needs a device at each end.");
     }
 
-    if (fromDeviceId.toString() === toDeviceId.toString()) {
+    if (sameDeviceId(fromDeviceId, toDeviceId)) {
       throw new BadDataException("A device cannot be linked to itself.");
     }
 
@@ -77,8 +199,222 @@ export class Service extends DatabaseService<Model> {
       );
     }
 
+    assertParentIsAnEnd(
+      RelationIdUtil.read(data, PARENT_DEVICE_KEYS),
+      fromDeviceId,
+      toDeviceId,
+    );
+
     return { createBy, carryForward: null };
   }
+
+  /*
+   * The same invariant, on the other write path.
+   *
+   * An update can break it two ways, and only one of them is obvious. The
+   * obvious one is setting a parent that is not on the link. The other is
+   * moving an END: re-point `toDevice` at a different switch and a parent
+   * that was valid a moment ago now names a device the link no longer
+   * touches. So the post-update state is what gets checked, assembled from
+   * the payload where it says something and from the stored row where it
+   * does not.
+   *
+   * An update matches a QUERY, not one row, and each matched row may have
+   * different ends — so every one of them is validated, and one bad row
+   * rejects the whole write. That is the conservative direction: a partial
+   * update that fixed some rows and left others contradicting themselves
+   * would be far harder to notice than a refusal.
+   *
+   * It also re-runs onBeforeCreate's TENANCY check on any end that moves.
+   * That check used to exist only on create, which left the update path
+   * able to re-point an end at another project's device — the exact threat
+   * onBeforeCreate's own comment describes, since the FK is global and the
+   * column is member-writable.
+   *
+   * Only costs a read when the payload touches an end or the parent at all;
+   * an update of ports or the bound monitor takes the early return.
+   */
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    const data: Record<string, unknown> = (updateBy.data ||
+      {}) as unknown as Record<string, unknown>;
+
+    const hierarchyKeys: Array<string> = [
+      ...FROM_DEVICE_KEYS,
+      ...TO_DEVICE_KEYS,
+      ...PARENT_DEVICE_KEYS,
+    ];
+
+    if (writtenKeys(data, hierarchyKeys).length === 0) {
+      return { updateBy, carryForward: null };
+    }
+
+    assertNoSqlExpression(data, hierarchyKeys);
+
+    const writtenFromDeviceId: ObjectID | null = RelationIdUtil.read(
+      data,
+      FROM_DEVICE_KEYS,
+    );
+    const writtenToDeviceId: ObjectID | null = RelationIdUtil.read(
+      data,
+      TO_DEVICE_KEYS,
+    );
+    const writtenParentDeviceId: ObjectID | null = RelationIdUtil.read(
+      data,
+      PARENT_DEVICE_KEYS,
+    );
+
+    /*
+     * Writing the parent key with an empty value is how a hierarchy is
+     * cleared back to a peer link. RelationIdUtil reads that as null, which
+     * is indistinguishable from "not written" — so the presence of the key
+     * (with a value that will actually be written; see writtenKeys), not
+     * the truthiness of its value, is what decides whether the stored
+     * parent still applies.
+     */
+    const isParentWritten: boolean =
+      writtenKeys(data, PARENT_DEVICE_KEYS).length > 0;
+
+    const existingLinks: Array<Model> = await this.findBy({
+      query: this.scopeQueryToCallerTenant(updateBy.query, updateBy.props),
+      select: {
+        _id: true,
+        projectId: true,
+        fromDeviceId: true,
+        toDeviceId: true,
+        parentDeviceId: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    /*
+     * An end that MOVED has to be re-checked for tenancy, exactly as
+     * onBeforeCreate checks it. The FK only requires the device row to
+     * exist — it is global — so without this a project member could
+     * re-point an end of their own link at another project's device and
+     * read its name straight off the map, which is the threat
+     * onBeforeCreate's own comment describes. The declared parent inherits
+     * the check for free: it has to be one of the two ends.
+     *
+     * Grouped by project because an update may in principle match links in
+     * more than one, and a device is only legitimate within its own.
+     */
+    /*
+     * Deduped: writing the same id to both ends is a self-link, and that
+     * has its own error below — it must not surface as "device not found".
+     */
+    const movedEndIds: Array<string> = [
+      ...new Set<string>(
+        [writtenFromDeviceId, writtenToDeviceId]
+          .filter((id: ObjectID | null): id is ObjectID => {
+            return Boolean(id);
+          })
+          .map((id: ObjectID) => {
+            return id.toString();
+          }),
+      ),
+    ];
+
+    if (movedEndIds.length > 0 && existingLinks.length > 0) {
+      /*
+       * Every project this write touches: the caller's own tenant, plus
+       * the project of each row the query matched (a root caller has no
+       * tenant, and only root can match rows across more than one). The
+       * new end has to be legitimate in all of them.
+       *
+       * Guarded on there being matched rows at all: a query that matched
+       * nothing writes nothing, and there is no link for a foreign device
+       * to end up attached to.
+       */
+      const projectIds: Set<string> = new Set<string>();
+      if (updateBy.props.tenantId) {
+        projectIds.add(updateBy.props.tenantId.toString());
+      }
+      for (const link of existingLinks) {
+        if (link.projectId) {
+          projectIds.add(link.projectId.toString());
+        }
+      }
+
+      /*
+       * Fail closed. No project to check against and an end on the move
+       * is not a safe update to wave through — it is the one shape where
+       * a device from anywhere could be attached to this link.
+       */
+      if (projectIds.size === 0) {
+        throw new BadDataException(
+          "Both devices must exist and belong to this project.",
+        );
+      }
+
+      for (const projectId of projectIds) {
+        const devices: Array<NetworkDevice> = await NetworkDeviceService.findBy(
+          {
+            query: {
+              _id: QueryHelper.any(movedEndIds),
+              projectId: new ObjectID(projectId),
+            },
+            select: { _id: true },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: { isRoot: true },
+          },
+        );
+
+        /*
+         * Compared as a SET of ids rather than as a count. A count says
+         * "as many rows came back as I asked about", which a duplicate row
+         * satisfies just as well as the right rows do — and this is the
+         * check standing between one project's map and another project's
+         * device names, so it should be answering the actual question.
+         */
+        const foundIds: Set<string> = new Set<string>(
+          devices.map((device: NetworkDevice) => {
+            return (device.id || device._id || "").toString().toLowerCase();
+          }),
+        );
+
+        const isMissingAnEnd: boolean = movedEndIds.some((id: string) => {
+          return !foundIds.has(id.toLowerCase());
+        });
+
+        if (isMissingAnEnd) {
+          throw new BadDataException(
+            "Both devices must exist and belong to this project.",
+          );
+        }
+      }
+    }
+
+    for (const link of existingLinks) {
+      const fromDeviceId: ObjectID | undefined =
+        writtenFromDeviceId || link.fromDeviceId;
+      const toDeviceId: ObjectID | undefined =
+        writtenToDeviceId || link.toDeviceId;
+      const parentDeviceId: ObjectID | null = isParentWritten
+        ? writtenParentDeviceId
+        : link.parentDeviceId || null;
+
+      // A row mid-migration with a missing end has no invariant to check.
+      if (!fromDeviceId || !toDeviceId) {
+        continue;
+      }
+
+      if (sameDeviceId(fromDeviceId, toDeviceId)) {
+        throw new BadDataException("A device cannot be linked to itself.");
+      }
+
+      assertParentIsAnEnd(parentDeviceId, fromDeviceId, toDeviceId);
+    }
+
+    return { updateBy, carryForward: null };
+  }
 }
 
 export default new Service();

package/Server/Types/Billing/MeteredPlan/AllMeteredPlans.ts

@@ -4,6 +4,19 @@ import ServerMeteredPlan from "./ServerMeteredPlan";
 import TelemetryMeteredPlanType from "./TelemetryMeteredPlan";
 import BadDataException from "../../../../Types/Exception/BadDataException";
 import ProductType from "../../../../Types/MeteredPlan/ProductType";
+import {
+  SESSION_REPLAY_PRICE_IN_USD_PER_GB,
+  TELEMETRY_PRICE_IN_USD_PER_GB,
+  TELEMETRY_PRICE_RETENTION_IN_DAYS,
+} from "../../../../Types/Billing/PayAsYouGoPricing";
+
+/*
+ * Per GB per day, derived from the advertised per-GB-per-15-days rate so the
+ * price the dashboard quotes a Free plan user and the price we actually meter
+ * cannot drift apart.
+ */
+const TELEMETRY_UNIT_COST_IN_USD: number =
+  TELEMETRY_PRICE_IN_USD_PER_GB / TELEMETRY_PRICE_RETENTION_IN_DAYS;
 
 export const ActiveMonitoringMeteredPlan: ActiveMonitoringMeteredPlanType =
   new ActiveMonitoringMeteredPlanType();
@@ -11,25 +24,25 @@ export const ActiveMonitoringMeteredPlan: ActiveMonitoringMeteredPlanType =
 export const LogDataIngestMeteredPlan: TelemetryMeteredPlanType =
   new TelemetryMeteredPlanType({
     productType: ProductType.Logs,
-    unitCostInUSD: 0.1 / 15, // 0.10 per 15 days per GB
+    unitCostInUSD: TELEMETRY_UNIT_COST_IN_USD, // 0.10 per 15 days per GB
   });
 
 export const MetricsDataIngestMeteredPlan: TelemetryMeteredPlanType =
   new TelemetryMeteredPlanType({
     productType: ProductType.Metrics,
-    unitCostInUSD: 0.1 / 15, // 0.10 per 15 days per GB
+    unitCostInUSD: TELEMETRY_UNIT_COST_IN_USD, // 0.10 per 15 days per GB
   });
 
 export const TracesDataIngestMetredPlan: TelemetryMeteredPlanType =
   new TelemetryMeteredPlanType({
     productType: ProductType.Traces,
-    unitCostInUSD: 0.1 / 15, // 0.10 per 15 days per GB
+    unitCostInUSD: TELEMETRY_UNIT_COST_IN_USD, // 0.10 per 15 days per GB
   });
 
 export const ProfilesDataIngestMeteredPlan: TelemetryMeteredPlanType =
   new TelemetryMeteredPlanType({
     productType: ProductType.Profiles,
-    unitCostInUSD: 0.1 / 15, // 0.10 per 15 days per GB
+    unitCostInUSD: TELEMETRY_UNIT_COST_IN_USD, // 0.10 per 15 days per GB
   });
 
 /*
@@ -43,7 +56,8 @@ export const ProfilesDataIngestMeteredPlan: TelemetryMeteredPlanType =
 export const SessionReplayDataIngestMeteredPlan: TelemetryMeteredPlanType =
   new TelemetryMeteredPlanType({
     productType: ProductType.SessionReplay,
-    unitCostInUSD: 2.0 / 15, // 2.00 per 15 days per GB
+    unitCostInUSD:
+      SESSION_REPLAY_PRICE_IN_USD_PER_GB / TELEMETRY_PRICE_RETENTION_IN_DAYS, // 2.00 per 15 days per GB
   });
 
 const AllMeteredPlans: Array<ServerMeteredPlan> = [