@oneuptime/common 7.0.3225 → 7.0.3233

package/Server/Utils/Monitor/Criteria/EvaluateOverTime.ts

@@ -1,4 +1,3 @@
-import MonitorMetricsByMinuteService from "../../../Services/MonitorMetricsByMinuteService";
 import Query from "../../../Types/AnalyticsDatabase/Query";
 import GreaterThanOrEqual from "Common/Types/BaseDatabase/GreaterThanOrEqual";
 import { LIMIT_PER_PROJECT } from "Common/Types/Database/LimitMax";
@@ -10,7 +9,9 @@ import {
   EvaluateOverTimeType,
 } from "Common/Types/Monitor/CriteriaFilter";
 import ObjectID from "Common/Types/ObjectID";
-import MonitorMetricsByMinute from "Common/Models/AnalyticsModels/MonitorMetricsByMinute";
+import Metric from "../../../../Models/AnalyticsModels/Metric";
+import MonitorMetricTypeUtil from "../../../../Utils/Monitor/MonitorMetricType";
+import MetricService from "../../../Services/MetricService";
 
 export default class EvaluateOverTime {
   public static async getValueOverTime(data: {
@@ -27,36 +28,35 @@ export default class EvaluateOverTime {
 
     // TODO: Query over miscData
 
-    const query: Query<MonitorMetricsByMinute> = {
+    const query: Query<Metric> = {
       createdAt: new GreaterThanOrEqual(lastMinutesDate),
-      monitorId: data.monitorId,
-      metricType: data.metricType,
+      serviceId: data.monitorId,
+      name: MonitorMetricTypeUtil.getMonitorMeticTypeByCheckOn(data.metricType),
     };
 
     if (data.miscData) {
-      query.miscData = data.miscData;
+      query.attributes = data.miscData;
     }
 
-    const monitorMetricsItems: Array<MonitorMetricsByMinute> =
-      await MonitorMetricsByMinuteService.findBy({
-        query: query,
-        limit: LIMIT_PER_PROJECT,
-        skip: 0,
-        props: {
-          isRoot: true,
-        },
-        select: {
-          metricValue: true,
-        },
-      });
+    const monitorMetricsItems: Array<Metric> = await MetricService.findBy({
+      query: query,
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        value: true,
+      },
+    });
 
     const values: Array<number | boolean> = monitorMetricsItems
-      .map((item: MonitorMetricsByMinute) => {
+      .map((item: Metric) => {
         if (data.metricType === CheckOn.IsOnline) {
-          return item.metricValue === 1;
+          return item.value === 1;
         }
 
-        return item.metricValue;
+        return item.value;
       })
       .filter((value: number | boolean | undefined) => {
         return value !== undefined;

package/Server/Utils/Monitor/MonitorIncident.ts

@@ -129,8 +129,6 @@ export default class MonitorIncident {
           continue;
         }
 
-        // create incident here.
-
         logger.debug(`${input.monitor.id?.toString()} - Create incident.`);
 
         const incident: Incident = new Incident();

package/Server/Utils/Monitor/MonitorResource.ts

@@ -1,4 +1,3 @@
-import MonitorMetricsByMinuteService from "../../Services/MonitorMetricsByMinuteService";
 import MonitorProbeService from "../../Services/MonitorProbeService";
 import MonitorService from "../../Services/MonitorService";
 import MonitorStatusTimelineService from "../../Services/MonitorStatusTimelineService";
@@ -22,7 +21,6 @@ import {
   CriteriaFilter,
   FilterCondition,
 } from "Common/Types/Monitor/CriteriaFilter";
-import CustomCodeMonitorResponse from "Common/Types/Monitor/CustomCodeMonitor/CustomCodeMonitorResponse";
 import IncomingMonitorRequest from "Common/Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
 import MonitorCriteria from "Common/Types/Monitor/MonitorCriteria";
 import MonitorCriteriaInstance from "Common/Types/Monitor/MonitorCriteriaInstance";
@@ -36,7 +34,6 @@ import ObjectID from "Common/Types/ObjectID";
 import ProbeApiIngestResponse from "Common/Types/Probe/ProbeApiIngestResponse";
 import ProbeMonitorResponse from "Common/Types/Probe/ProbeMonitorResponse";
 import Typeof from "Common/Types/Typeof";
-import MonitorMetricsByMinute from "Common/Models/AnalyticsModels/MonitorMetricsByMinute";
 import Monitor from "Common/Models/DatabaseModels/Monitor";
 import MonitorProbe from "Common/Models/DatabaseModels/MonitorProbe";
 import MonitorStatusTimeline from "Common/Models/DatabaseModels/MonitorStatusTimeline";
@@ -51,6 +48,13 @@ import MonitorIncident from "./MonitorIncident";
 import MonitorAlert from "./MonitorAlert";
 import MonitorStatusTimelineUtil from "./MonitorStatusTimeline";
 import Semaphore, { SemaphoreMutex } from "../../Infrastructure/Semaphore";
+import Metric, {
+  MetricPointType,
+  ServiceType,
+} from "../../../Models/AnalyticsModels/Metric";
+import MetricService from "../../Services/MetricService";
+import MonitorMetricType from "../../../Types/Monitor/MonitorMetricType";
+import TelemetryUtil from "../Telemetry/Telemetry";
 
 export default class MonitorResourceUtil {
   public static async monitorResource(
@@ -573,7 +577,7 @@ export default class MonitorResourceUtil {
       return;
     }
 
-    const itemsToSave: Array<MonitorMetricsByMinute> = [];
+    const itemsToSave: Array<Metric> = [];
 
     if (
       (data.dataToProcess as ServerMonitorResponse).basicInfrastructureMetrics
@@ -593,15 +597,25 @@ export default class MonitorResourceUtil {
           isOnline = false;
         }
 
-        const monitorMetricsByMinute: MonitorMetricsByMinute =
-          new MonitorMetricsByMinute();
+        const monitorMetric: Metric = new Metric();
+
+        monitorMetric.projectId = data.projectId;
+        monitorMetric.serviceId = data.monitorId;
+        monitorMetric.serviceType = ServiceType.Monitor;
+        monitorMetric.name = MonitorMetricType.IsOnline;
+        monitorMetric.description = CheckOn.IsOnline + " status for monitor";
+        monitorMetric.value = isOnline ? 1 : 0;
+        monitorMetric.unit = "";
+        monitorMetric.attributes = {
+          monitorId: data.monitorId.toString(),
+          projectId: data.projectId.toString(),
+        };
 
-        monitorMetricsByMinute.monitorId = data.monitorId;
-        monitorMetricsByMinute.projectId = data.projectId;
-        monitorMetricsByMinute.metricType = CheckOn.IsOnline;
-        monitorMetricsByMinute.metricValue = isOnline ? 1 : 0;
+        monitorMetric.time = OneUptimeDate.getCurrentDate();
+        monitorMetric.timeUnixNano = OneUptimeDate.getCurrentDateAsUnixNano();
+        monitorMetric.metricPointType = MetricPointType.Sum;
 
-        itemsToSave.push(monitorMetricsByMinute);
+        itemsToSave.push(monitorMetric);
       }
 
       const basicMetrics: BasicInfrastructureMetrics | undefined = (
@@ -613,42 +627,73 @@ export default class MonitorResourceUtil {
       }
 
       if (basicMetrics.cpuMetrics) {
-        const monitorMetricsByMinute: MonitorMetricsByMinute =
-          new MonitorMetricsByMinute();
-        monitorMetricsByMinute.monitorId = data.monitorId;
-        monitorMetricsByMinute.projectId = data.projectId;
-        monitorMetricsByMinute.metricType = CheckOn.CPUUsagePercent;
-        monitorMetricsByMinute.metricValue =
-          basicMetrics.cpuMetrics.percentUsed;
-
-        itemsToSave.push(monitorMetricsByMinute);
+        const monitorMetric: Metric = new Metric();
+
+        monitorMetric.projectId = data.projectId;
+        monitorMetric.serviceId = data.monitorId;
+        monitorMetric.serviceType = ServiceType.Monitor;
+        monitorMetric.name = MonitorMetricType.CPUUsagePercent;
+        monitorMetric.description = CheckOn.CPUUsagePercent + " of Server/VM";
+        monitorMetric.value = basicMetrics.cpuMetrics.percentUsed;
+        monitorMetric.unit = "%";
+        monitorMetric.attributes = {
+          monitorId: data.monitorId.toString(),
+          projectId: data.projectId.toString(),
+        };
+
+        monitorMetric.time = OneUptimeDate.getCurrentDate();
+        monitorMetric.timeUnixNano = OneUptimeDate.getCurrentDateAsUnixNano();
+        monitorMetric.metricPointType = MetricPointType.Sum;
+
+        itemsToSave.push(monitorMetric);
       }
 
       if (basicMetrics.memoryMetrics) {
-        const monitorMetricsByMinute: MonitorMetricsByMinute =
-          new MonitorMetricsByMinute();
-        monitorMetricsByMinute.monitorId = data.monitorId;
-        monitorMetricsByMinute.projectId = data.projectId;
-        monitorMetricsByMinute.metricType = CheckOn.MemoryUsagePercent;
-        monitorMetricsByMinute.metricValue =
-          basicMetrics.memoryMetrics.percentUsed;
-
-        itemsToSave.push(monitorMetricsByMinute);
+        const monitorMetric: Metric = new Metric();
+
+        monitorMetric.projectId = data.projectId;
+        monitorMetric.serviceId = data.monitorId;
+        monitorMetric.serviceType = ServiceType.Monitor;
+        monitorMetric.name = MonitorMetricType.MemoryUsagePercent;
+        monitorMetric.description =
+          CheckOn.MemoryUsagePercent + " of Server/VM";
+        monitorMetric.value = basicMetrics.memoryMetrics.percentUsed;
+        monitorMetric.unit = "%";
+        monitorMetric.attributes = {
+          monitorId: data.monitorId.toString(),
+          projectId: data.projectId.toString(),
+        };
+
+        monitorMetric.time = OneUptimeDate.getCurrentDate();
+        monitorMetric.timeUnixNano = OneUptimeDate.getCurrentDateAsUnixNano();
+        monitorMetric.metricPointType = MetricPointType.Sum;
+
+        itemsToSave.push(monitorMetric);
       }
 
       if (basicMetrics.diskMetrics && basicMetrics.diskMetrics.length > 0) {
         for (const diskMetric of basicMetrics.diskMetrics) {
-          const monitorMetricsByMinute: MonitorMetricsByMinute =
-            new MonitorMetricsByMinute();
-          monitorMetricsByMinute.monitorId = data.monitorId;
-          monitorMetricsByMinute.projectId = data.projectId;
-          monitorMetricsByMinute.metricType = CheckOn.DiskUsagePercent;
-          monitorMetricsByMinute.metricValue = diskMetric.percentUsed;
-          monitorMetricsByMinute.miscData = {
+          const monitorMetric: Metric = new Metric();
+
+          monitorMetric.projectId = data.projectId;
+          monitorMetric.serviceId = data.monitorId;
+          monitorMetric.serviceType = ServiceType.Monitor;
+          monitorMetric.name = MonitorMetricType.DiskUsagePercent;
+          monitorMetric.description =
+            CheckOn.DiskUsagePercent + " of Server/VM";
+          monitorMetric.value = diskMetric.percentUsed;
+          monitorMetric.unit = "%";
+          monitorMetric.attributes = {
+            monitorId: data.monitorId.toString(),
+            projectId: data.projectId.toString(),
             diskPath: diskMetric.diskPath,
           };
 
-          itemsToSave.push(monitorMetricsByMinute);
+          monitorMetric.time = OneUptimeDate.getCurrentDate();
+          monitorMetric.timeUnixNano = OneUptimeDate.getCurrentDateAsUnixNano();
+          monitorMetric.metricPointType = MetricPointType.Sum;
+
+          itemsToSave.push(monitorMetric);
         }
       }
     }
@@ -657,21 +702,30 @@ export default class MonitorResourceUtil {
       (data.dataToProcess as ProbeMonitorResponse).customCodeMonitorResponse
         ?.executionTimeInMS
     ) {
-      const monitorMetricsByMinute: MonitorMetricsByMinute =
-        new MonitorMetricsByMinute();
-      monitorMetricsByMinute.monitorId = data.monitorId;
-      monitorMetricsByMinute.projectId = data.projectId;
-      monitorMetricsByMinute.metricType = CheckOn.ExecutionTime;
-      monitorMetricsByMinute.metricValue = (
+      const monitorMetric: Metric = new Metric();
+
+      monitorMetric.projectId = data.projectId;
+      monitorMetric.serviceId = data.monitorId;
+      monitorMetric.serviceType = ServiceType.Monitor;
+      monitorMetric.name = MonitorMetricType.ExecutionTime;
+      monitorMetric.description = CheckOn.ExecutionTime + " of this monitor";
+      monitorMetric.value = (
         data.dataToProcess as ProbeMonitorResponse
       ).customCodeMonitorResponse?.executionTimeInMS;
-      monitorMetricsByMinute.miscData = {
+      monitorMetric.unit = "ms";
+      monitorMetric.attributes = {
+        monitorId: data.monitorId.toString(),
+        projectId: data.projectId.toString(),
         probeId: (
           data.dataToProcess as ProbeMonitorResponse
         ).probeId.toString(),
       };
 
-      itemsToSave.push(monitorMetricsByMinute);
+      monitorMetric.time = OneUptimeDate.getCurrentDate();
+      monitorMetric.timeUnixNano = OneUptimeDate.getCurrentDateAsUnixNano();
+      monitorMetric.metricPointType = MetricPointType.Sum;
+
+      itemsToSave.push(monitorMetric);
     }
 
     if (
@@ -685,14 +739,18 @@ export default class MonitorResourceUtil {
       for (const syntheticMonitorResponse of (
         data.dataToProcess as ProbeMonitorResponse
       ).syntheticMonitorResponse || []) {
-        const monitorMetricsByMinute: MonitorMetricsByMinute =
-          new MonitorMetricsByMinute();
-        monitorMetricsByMinute.monitorId = data.monitorId;
-        monitorMetricsByMinute.projectId = data.projectId;
-        monitorMetricsByMinute.metricType = CheckOn.ExecutionTime;
-        monitorMetricsByMinute.metricValue =
-          syntheticMonitorResponse.executionTimeInMS;
-        monitorMetricsByMinute.miscData = {
+        const monitorMetric: Metric = new Metric();
+
+        monitorMetric.projectId = data.projectId;
+        monitorMetric.serviceId = data.monitorId;
+        monitorMetric.serviceType = ServiceType.Monitor;
+        monitorMetric.name = MonitorMetricType.ExecutionTime;
+        monitorMetric.description = CheckOn.ExecutionTime + " of this monitor";
+        monitorMetric.value = syntheticMonitorResponse.executionTimeInMS;
+        monitorMetric.unit = "ms";
+        monitorMetric.attributes = {
+          monitorId: data.monitorId.toString(),
+          projectId: data.projectId.toString(),
           probeId: (
             data.dataToProcess as ProbeMonitorResponse
           ).probeId.toString(),
@@ -700,118 +758,119 @@ export default class MonitorResourceUtil {
           screenSizeType: syntheticMonitorResponse.screenSizeType,
         };
 
-        itemsToSave.push(monitorMetricsByMinute);
+        monitorMetric.time = OneUptimeDate.getCurrentDate();
+        monitorMetric.timeUnixNano = OneUptimeDate.getCurrentDateAsUnixNano();
+        monitorMetric.metricPointType = MetricPointType.Sum;
+
+        itemsToSave.push(monitorMetric);
       }
     }
 
     if ((data.dataToProcess as ProbeMonitorResponse).responseTimeInMs) {
-      const monitorMetricsByMinute: MonitorMetricsByMinute =
-        new MonitorMetricsByMinute();
-      monitorMetricsByMinute.monitorId = data.monitorId;
-      monitorMetricsByMinute.projectId = data.projectId;
-      monitorMetricsByMinute.metricType = CheckOn.ResponseTime;
-      monitorMetricsByMinute.metricValue = (
+      const monitorMetric: Metric = new Metric();
+
+      monitorMetric.projectId = data.projectId;
+      monitorMetric.serviceId = data.monitorId;
+      monitorMetric.serviceType = ServiceType.Monitor;
+      monitorMetric.name = MonitorMetricType.ResponseTime;
+      monitorMetric.description = CheckOn.ResponseTime + " of this monitor";
+      monitorMetric.value = (
         data.dataToProcess as ProbeMonitorResponse
       ).responseTimeInMs;
-      monitorMetricsByMinute.miscData = {
+      monitorMetric.unit = "ms";
+      monitorMetric.attributes = {
+        monitorId: data.monitorId.toString(),
+        projectId: data.projectId.toString(),
         probeId: (
           data.dataToProcess as ProbeMonitorResponse
         ).probeId.toString(),
       };
 
-      itemsToSave.push(monitorMetricsByMinute);
+      monitorMetric.time = OneUptimeDate.getCurrentDate();
+      monitorMetric.timeUnixNano = OneUptimeDate.getCurrentDateAsUnixNano();
+      monitorMetric.metricPointType = MetricPointType.Sum;
+
+      itemsToSave.push(monitorMetric);
     }
 
     if ((data.dataToProcess as ProbeMonitorResponse).isOnline !== undefined) {
-      const monitorMetricsByMinute: MonitorMetricsByMinute =
-        new MonitorMetricsByMinute();
-      monitorMetricsByMinute.monitorId = data.monitorId;
-      monitorMetricsByMinute.projectId = data.projectId;
-      monitorMetricsByMinute.metricType = CheckOn.IsOnline;
-      monitorMetricsByMinute.metricValue = 0;
-      monitorMetricsByMinute.miscData = {
+      const monitorMetric: Metric = new Metric();
+
+      monitorMetric.projectId = data.projectId;
+      monitorMetric.serviceId = data.monitorId;
+      monitorMetric.serviceType = ServiceType.Monitor;
+      monitorMetric.name = MonitorMetricType.IsOnline;
+      monitorMetric.description = CheckOn.IsOnline + " status for monitor";
+      monitorMetric.value = (data.dataToProcess as ProbeMonitorResponse)
+        .isOnline
+        ? 1
+        : 0;
+      monitorMetric.unit = "";
+      monitorMetric.attributes = {
+        monitorId: data.monitorId.toString(),
+        projectId: data.projectId.toString(),
         probeId: (
           data.dataToProcess as ProbeMonitorResponse
         ).probeId.toString(),
       };
 
-      if ((data.dataToProcess as ProbeMonitorResponse).isOnline) {
-        monitorMetricsByMinute.metricValue = 1;
-      }
+      monitorMetric.time = OneUptimeDate.getCurrentDate();
+      monitorMetric.timeUnixNano = OneUptimeDate.getCurrentDateAsUnixNano();
+      monitorMetric.metricPointType = MetricPointType.Sum;
 
-      itemsToSave.push(monitorMetricsByMinute);
+      itemsToSave.push(monitorMetric);
     }
 
     if ((data.dataToProcess as ProbeMonitorResponse).responseCode) {
-      const monitorMetricsByMinute: MonitorMetricsByMinute =
-        new MonitorMetricsByMinute();
-      monitorMetricsByMinute.monitorId = data.monitorId;
-      monitorMetricsByMinute.projectId = data.projectId;
-      monitorMetricsByMinute.metricType = CheckOn.ResponseStatusCode;
-      monitorMetricsByMinute.metricValue = (
+      const monitorMetric: Metric = new Metric();
+
+      monitorMetric.projectId = data.projectId;
+      monitorMetric.serviceId = data.monitorId;
+      monitorMetric.serviceType = ServiceType.Monitor;
+      monitorMetric.name = MonitorMetricType.ResponseStatusCode;
+      monitorMetric.description =
+        CheckOn.ResponseStatusCode + " for this monitor";
+      monitorMetric.value = (
         data.dataToProcess as ProbeMonitorResponse
       ).responseCode;
-      monitorMetricsByMinute.miscData = {
+      monitorMetric.unit = "Status Code";
+      monitorMetric.attributes = {
+        monitorId: data.monitorId.toString(),
+        projectId: data.projectId.toString(),
         probeId: (
           data.dataToProcess as ProbeMonitorResponse
         ).probeId.toString(),
       };
 
-      itemsToSave.push(monitorMetricsByMinute);
-    }
-
-    if ((data.dataToProcess as ProbeMonitorResponse).syntheticMonitorResponse) {
-      for (const syntheticMonitorResponse of (
-        data.dataToProcess as ProbeMonitorResponse
-      ).syntheticMonitorResponse || []) {
-        const monitorMetricsByMinute: MonitorMetricsByMinute =
-          new MonitorMetricsByMinute();
-        monitorMetricsByMinute.monitorId = data.monitorId;
-        monitorMetricsByMinute.projectId = data.projectId;
-        monitorMetricsByMinute.metricType = CheckOn.ExecutionTime;
-        monitorMetricsByMinute.metricValue =
-          syntheticMonitorResponse.executionTimeInMS;
-        monitorMetricsByMinute.miscData = {
-          probeId: (
-            data.dataToProcess as ProbeMonitorResponse
-          ).probeId.toString(),
-          browserType: syntheticMonitorResponse.browserType,
-          screenSizeType: syntheticMonitorResponse.screenSizeType,
-        };
-
-        itemsToSave.push(monitorMetricsByMinute);
-      }
-    }
+      monitorMetric.time = OneUptimeDate.getCurrentDate();
+      monitorMetric.timeUnixNano = OneUptimeDate.getCurrentDateAsUnixNano();
+      monitorMetric.metricPointType = MetricPointType.Sum;
 
-    if (
-      (data.dataToProcess as ProbeMonitorResponse).customCodeMonitorResponse
-    ) {
-      const customCodeMonitorResponse: CustomCodeMonitorResponse = (
-        data.dataToProcess as ProbeMonitorResponse
-      ).customCodeMonitorResponse!;
-
-      const monitorMetricsByMinute: MonitorMetricsByMinute =
-        new MonitorMetricsByMinute();
-      monitorMetricsByMinute.monitorId = data.monitorId;
-      monitorMetricsByMinute.projectId = data.projectId;
-      monitorMetricsByMinute.metricType = CheckOn.ExecutionTime;
-      monitorMetricsByMinute.metricValue =
-        customCodeMonitorResponse.executionTimeInMS;
-      monitorMetricsByMinute.miscData = {
-        probeId: (
-          data.dataToProcess as ProbeMonitorResponse
-        ).probeId.toString(),
-      };
-
-      itemsToSave.push(monitorMetricsByMinute);
+      itemsToSave.push(monitorMetric);
     }
 
-    await MonitorMetricsByMinuteService.createMany({
+    await MetricService.createMany({
       items: itemsToSave,
       props: {
         isRoot: true,
       },
     });
+
+    // index attributes.
+    TelemetryUtil.indexAttributes({
+      attributes: [
+        "monitorId",
+        "projectId",
+        "probeId",
+        "browserType",
+        "screenSizeType",
+        "diskPath",
+      ],
+      projectId: data.projectId,
+      telemetryType: TelemetryType.Metric,
+    }).catch((err: Error) => {
+      logger.error(err);
+    });
   }
 
   private static async processMonitorStep(input: {

package/Server/Utils/Telemetry/Telemetry.ts

@@ -0,0 +1,154 @@
+import { JSONArray, JSONObject, JSONValue } from "../../../Types/JSON";
+import JSONFunctions from "../../../Types/JSONFunctions";
+import ObjectID from "../../../Types/ObjectID";
+import TelemetryType from "../../../Types/Telemetry/TelemetryType";
+import ArrayUtil from "../../../Utils/Array";
+import GlobalCache from "../../Infrastructure/GlobalCache";
+import TelemetryAttributeService from "../../Services/TelemetryAttributeService";
+
+export default class TelemetryUtil {
+  public static async indexAttributes(data: {
+    attributes: string[];
+    projectId: ObjectID;
+    telemetryType: TelemetryType;
+  }): Promise<void> {
+    // index attributes
+
+    const cacheKey: string =
+      data.projectId.toString() + "_" + data.telemetryType;
+
+    // get keys from cache
+    const cacheKeys: string[] =
+      (await GlobalCache.getStringArray("telemetryAttributesKeys", cacheKey)) ||
+      [];
+
+    let isKeysMissingInCache: boolean = false;
+
+    // check if keys are missing in cache
+
+    for (const key of data.attributes) {
+      if (!cacheKeys.includes(key)) {
+        isKeysMissingInCache = true;
+        break;
+      }
+    }
+
+    // merge keys and remove duplicates
+    if (isKeysMissingInCache) {
+      const dbKeys: string[] = await TelemetryAttributeService.fetchAttributes({
+        projectId: data.projectId,
+        telemetryType: data.telemetryType,
+      });
+
+      const mergedKeys: Array<string> = ArrayUtil.removeDuplicates([
+        ...dbKeys,
+        ...data.attributes,
+        ...cacheKeys,
+      ]);
+
+      await GlobalCache.setStringArray(
+        "telemetryAttributesKeys",
+        cacheKey,
+        mergedKeys,
+      );
+
+      await TelemetryAttributeService.refreshAttributes({
+        projectId: data.projectId,
+        telemetryType: data.telemetryType,
+        attributes: mergedKeys,
+      });
+    }
+  }
+
+  public static getAttributes(data: {
+    items: JSONArray;
+    telemetryServiceId?: ObjectID;
+    telemetryServiceName?: string;
+  }): JSONObject {
+    const { items } = data;
+
+    const finalObj: JSONObject = {};
+    // We need to convert this to date.
+    const attributes: JSONArray = items;
+
+    type GetValueFunction = (value: JSONValue) => JSONValue;
+
+    const getValue: GetValueFunction = (value: JSONValue): JSONValue => {
+      value = value as JSONObject;
+
+      if (value["stringValue"]) {
+        value = value["stringValue"] as string;
+      } else if (value["intValue"]) {
+        value = value["intValue"] as number;
+      } else if (value["doubleValue"]) {
+        value = value["doubleValue"] as number;
+      } else if (value["boolValue"]) {
+        value = value["boolValue"] as boolean;
+      } else if (
+        value["arrayValue"] &&
+        (value["arrayValue"] as JSONObject)["values"]
+      ) {
+        value = (
+          (value["arrayValue"] as JSONObject)["values"] as JSONArray
+        ).map((v: JSONObject) => {
+          return getValue(v);
+        });
+      } else if (
+        value["mapValue"] &&
+        (value["mapValue"] as JSONObject)["fields"]
+      ) {
+        value = getValue((value["mapValue"] as JSONObject)["fields"]);
+      } else if (value["nullValue"]) {
+        value = null;
+      }
+
+      return value;
+    };
+
+    if (attributes) {
+      for (const attribute of attributes) {
+        if (attribute["key"] && typeof attribute["key"] === "string") {
+          const value: JSONValue = getValue(attribute["value"]);
+          finalObj[attribute["key"]] = value;
+        }
+      }
+    }
+
+    // add oneuptime specific attributes
+    if (!finalObj["oneuptime"]) {
+      finalObj["oneuptime"] = {};
+    }
+
+    if (!(finalObj["oneuptime"] as JSONObject)["telemetry"]) {
+      (finalObj["oneuptime"] as JSONObject)["telemetry"] = {};
+    }
+
+    if (
+      !((finalObj["oneuptime"] as JSONObject)["telemetry"] as JSONObject)[
+        "service"
+      ]
+    ) {
+      ((finalObj["oneuptime"] as JSONObject)["telemetry"] as JSONObject)[
+        "service"
+      ] = {};
+    }
+
+    if (data.telemetryServiceId) {
+      (
+        ((finalObj["oneuptime"] as JSONObject)["telemetry"] as JSONObject)[
+          "service"
+        ] as JSONObject
+      )["id"] = data.telemetryServiceId.toString();
+    }
+
+    if (data.telemetryServiceName) {
+      (
+        ((finalObj["oneuptime"] as JSONObject)["telemetry"] as JSONObject)[
+          "service"
+        ] as JSONObject
+      )["name"] = data.telemetryServiceName;
+    }
+
+    return JSONFunctions.flattenObject(finalObj);
+  }
+}