@oneuptime/common 10.0.38 → 10.0.40

package/Server/Services/TelemetryUsageBillingService.ts

@@ -16,6 +16,8 @@ import SpanService from "./SpanService";
 import LogService from "./LogService";
 import MetricService from "./MetricService";
 import ExceptionInstanceService from "./ExceptionInstanceService";
+import ProfileService from "./ProfileService";
+import ProfileSampleService from "./ProfileSampleService";
 import AnalyticsQueryHelper from "../Types/AnalyticsDatabase/QueryHelper";
 import DiskSize from "../../Types/DiskSize";
 import logger from "../Utils/Logger";
@@ -26,6 +28,8 @@ import {
   AverageLogRowSizeInBytes,
   AverageMetricRowSizeInBytes,
   AverageExceptionRowSizeInBytes,
+  AverageProfileRowSizeInBytes,
+  AverageProfileSampleRowSizeInBytes,
   IsBillingEnabled,
 } from "../EnvironmentConfig";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
@@ -81,7 +85,14 @@ export class Service extends DatabaseService<Model> {
     const averageExceptionRowSizeInBytes: number =
       this.getAverageExceptionRowSize();
 
-    if (data.productType !== ProductType.Traces && averageRowSizeInBytes <= 0) {
+    const averageProfileSampleRowSizeInBytes: number =
+      this.getAverageProfileSampleRowSize();
+
+    if (
+      data.productType !== ProductType.Traces &&
+      data.productType !== ProductType.Profiles &&
+      averageRowSizeInBytes <= 0
+    ) {
       return;
     }
 
@@ -93,6 +104,14 @@ export class Service extends DatabaseService<Model> {
       return;
     }
 
+    if (
+      data.productType === ProductType.Profiles &&
+      averageRowSizeInBytes <= 0 &&
+      averageProfileSampleRowSizeInBytes <= 0
+    ) {
+      return;
+    }
+
     const usageDayString: string = OneUptimeDate.getDateString(usageDate);
     const startOfDay: Date = OneUptimeDate.getStartOfDay(usageDate);
     const endOfDay: Date = OneUptimeDate.getEndOfDay(usageDate);
@@ -223,6 +242,44 @@ export class Service extends DatabaseService<Model> {
           }
 
           estimatedBytes = totalRowCount * averageRowSizeInBytes;
+        } else if (data.productType === ProductType.Profiles) {
+          const profileCount: PositiveNumber = await ProfileService.countBy({
+            query: {
+              projectId: data.projectId,
+              serviceId: service.id,
+              startTime: AnalyticsQueryHelper.inBetween(startOfDay, endOfDay),
+            },
+            skip: 0,
+            limit: LIMIT_INFINITY,
+            props: {
+              isRoot: true,
+            },
+          });
+
+          const profileSampleCount: PositiveNumber =
+            await ProfileSampleService.countBy({
+              query: {
+                projectId: data.projectId,
+                serviceId: service.id,
+                time: AnalyticsQueryHelper.inBetween(startOfDay, endOfDay),
+              },
+              skip: 0,
+              limit: LIMIT_INFINITY,
+              props: {
+                isRoot: true,
+              },
+            });
+
+          const totalProfileCount: number = profileCount.toNumber();
+          const totalProfileSampleCount: number = profileSampleCount.toNumber();
+
+          if (totalProfileCount <= 0 && totalProfileSampleCount <= 0) {
+            continue;
+          }
+
+          estimatedBytes =
+            totalProfileCount * averageRowSizeInBytes +
+            totalProfileSampleCount * averageProfileSampleRowSizeInBytes;
         }
       } catch (error) {
         logger.error(
@@ -268,7 +325,8 @@ export class Service extends DatabaseService<Model> {
     if (
       data.productType !== ProductType.Traces &&
       data.productType !== ProductType.Metrics &&
-      data.productType !== ProductType.Logs
+      data.productType !== ProductType.Logs &&
+      data.productType !== ProductType.Profiles
     ) {
       throw new BadDataException(
         "This product type is not a telemetry product type.",
@@ -370,7 +428,8 @@ export class Service extends DatabaseService<Model> {
     if (
       productType !== ProductType.Traces &&
       productType !== ProductType.Logs &&
-      productType !== ProductType.Metrics
+      productType !== ProductType.Metrics &&
+      productType !== ProductType.Profiles
     ) {
       return fallbackSize;
     }
@@ -380,6 +439,7 @@ export class Service extends DatabaseService<Model> {
         [ProductType.Traces]: AverageSpanRowSizeInBytes,
         [ProductType.Logs]: AverageLogRowSizeInBytes,
         [ProductType.Metrics]: AverageMetricRowSizeInBytes,
+        [ProductType.Profiles]: AverageProfileRowSizeInBytes,
       }[productType] ?? fallbackSize;
 
     if (!Number.isFinite(value) || value <= 0) {
@@ -402,6 +462,20 @@ export class Service extends DatabaseService<Model> {
 
     return AverageExceptionRowSizeInBytes;
   }
+
+  private getAverageProfileSampleRowSize(): number {
+    const fallbackSize: number = 512;
+
+    if (!Number.isFinite(AverageProfileSampleRowSizeInBytes)) {
+      return fallbackSize;
+    }
+
+    if (AverageProfileSampleRowSizeInBytes <= 0) {
+      return fallbackSize;
+    }
+
+    return AverageProfileSampleRowSizeInBytes;
+  }
 }
 
 export default new Service();

package/Server/Services/WorkspaceNotificationSummaryService.ts

@@ -241,6 +241,9 @@ export class Service extends DatabaseService<WorkspaceNotificationSummary> {
     items: Array<WorkspaceNotificationSummaryItem>,
     item: WorkspaceNotificationSummaryItem,
   ): boolean {
+    if (items.includes(WorkspaceNotificationSummaryItem.All)) {
+      return true;
+    }
     return items.includes(item);
   }
 
@@ -822,6 +825,11 @@ export class Service extends DatabaseService<WorkspaceNotificationSummary> {
             ackResolve.push(
               `Ack: ${Service.bold(td.ackBy)} in ${Service.formatDuration(OneUptimeDate.getMinutesBetweenTwoDates(td.declaredAt || inc.createdAt!, td.ackAt))}`,
             );
+          } else if (td?.resolvedBy && td?.resolvedAt) {
+            // If not explicitly acknowledged but resolved, ack time = resolve time
+            ackResolve.push(
+              `Ack: ${Service.bold(td.resolvedBy)} in ${Service.formatDuration(OneUptimeDate.getMinutesBetweenTwoDates(td.declaredAt || inc.createdAt!, td.resolvedAt))}`,
+            );
           } else {
             ackResolve.push(`_Not yet acknowledged_`);
           }
@@ -1251,6 +1259,11 @@ export class Service extends DatabaseService<WorkspaceNotificationSummary> {
             ackResolve.push(
               `Ack: ${Service.bold(td.ackBy)} in ${Service.formatDuration(OneUptimeDate.getMinutesBetweenTwoDates(td.declaredAt || a.createdAt!, td.ackAt))}`,
             );
+          } else if (td?.resolvedBy && td?.resolvedAt) {
+            // If not explicitly acknowledged but resolved, ack time = resolve time
+            ackResolve.push(
+              `Ack: ${Service.bold(td.resolvedBy)} in ${Service.formatDuration(OneUptimeDate.getMinutesBetweenTwoDates(td.declaredAt || a.createdAt!, td.resolvedAt))}`,
+            );
           } else {
             ackResolve.push(`_Not yet acknowledged_`);
           }
@@ -1433,8 +1446,9 @@ export class Service extends DatabaseService<WorkspaceNotificationSummary> {
     let total: number = 0;
     let count: number = 0;
     for (const [, td] of tlMap) {
+      // For ack: if not explicitly acknowledged but resolved, use resolve time as ack time
       const eventTime: Date | undefined =
-        kind === "ack" ? td.ackAt : td.resolvedAt;
+        kind === "ack" ? td.ackAt || td.resolvedAt : td.resolvedAt;
       if (eventTime && td.declaredAt) {
         total += OneUptimeDate.getMinutesBetweenTwoDates(
           td.declaredAt,

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

@@ -26,11 +26,18 @@ export const TracesDataIngestMetredPlan: TelemetryMeteredPlanType =
     unitCostInUSD: 0.1 / 15, // 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
+  });
+
 const AllMeteredPlans: Array<ServerMeteredPlan> = [
   ActiveMonitoringMeteredPlan,
   LogDataIngestMeteredPlan,
   MetricsDataIngestMeteredPlan,
   TracesDataIngestMetredPlan,
+  ProfilesDataIngestMeteredPlan,
 ];
 
 export class MeteredPlanUtil {
@@ -44,6 +51,8 @@ export class MeteredPlanUtil {
       return MetricsDataIngestMeteredPlan;
     } else if (productType === ProductType.Traces) {
       return TracesDataIngestMetredPlan;
+    } else if (productType === ProductType.Profiles) {
+      return ProfilesDataIngestMeteredPlan;
     } else if (productType === ProductType.ActiveMonitoring) {
       return ActiveMonitoringMeteredPlan;
     }

package/Server/Types/Workflow/Components/Conditions/IfElse.ts

@@ -9,6 +9,7 @@ import ComponentMetadata, {
 import ComponentID from "../../../../../Types/Workflow/ComponentID";
 import Components, {
   ConditionOperator,
+  ConditionValueType,
 } from "../../../../../Types/Workflow/Components/Condition";
 import CaptureSpan from "../../../../Utils/Telemetry/CaptureSpan";
 
@@ -61,29 +62,75 @@ export default class IfElse extends ComponentCode {
        * Inject dependencies
        */
 
-      for (const key in args) {
-        if (key === "operator") {
-          continue;
-        }
-
-        const value: JSONValue = args[key];
+      // Get explicit types from dropdowns, default to text
+      let input1Type: ConditionValueType =
+        (args["input-1-type"] as ConditionValueType) || ConditionValueType.Text;
+      let input2Type: ConditionValueType =
+        (args["input-2-type"] as ConditionValueType) || ConditionValueType.Text;
 
-        let shouldHaveQuotes: boolean = false;
+      /*
+       * When types differ, coerce both to the more specific type
+       * so comparisons like text "true" == boolean true work correctly.
+       * Priority: Null/Undefined keep as-is, Boolean > Number > Text.
+       */
+      if (input1Type !== input2Type) {
+        type IsNullishFunction = (t: ConditionValueType) => boolean;
+
+        const isNullish: IsNullishFunction = (
+          t: ConditionValueType,
+        ): boolean => {
+          return (
+            t === ConditionValueType.Null || t === ConditionValueType.Undefined
+          );
+        };
 
-        if (
-          typeof value === "string" &&
-          value !== "null" &&
-          value !== "undefined"
-        ) {
-          shouldHaveQuotes = true;
+        if (!isNullish(input1Type) && !isNullish(input2Type)) {
+          const typePriority: Record<string, number> = {
+            [ConditionValueType.Boolean]: 2,
+            [ConditionValueType.Number]: 1,
+            [ConditionValueType.Text]: 0,
+          };
+
+          const p1: number = typePriority[input1Type] ?? 0;
+          const p2: number = typePriority[input2Type] ?? 0;
+          const commonType: ConditionValueType =
+            p1 >= p2 ? input1Type : input2Type;
+          input1Type = commonType;
+          input2Type = commonType;
         }
+      }
 
-        if (typeof value === "object") {
-          args[key] = JSON.stringify(args[key]);
+      type FormatValueFunction = (
+        value: JSONValue,
+        valueType: ConditionValueType,
+      ) => string;
+
+      const formatValue: FormatValueFunction = (
+        value: JSONValue,
+        valueType: ConditionValueType,
+      ): string => {
+        const strValue: string =
+          typeof value === "object"
+            ? JSON.stringify(value)
+            : String(value ?? "");
+
+        switch (valueType) {
+          case ConditionValueType.Boolean:
+            return strValue === "true" ? "true" : "false";
+          case ConditionValueType.Number:
+            return isNaN(Number(strValue)) ? "0" : String(Number(strValue));
+          case ConditionValueType.Null:
+            return "null";
+          case ConditionValueType.Undefined:
+            return "undefined";
+          case ConditionValueType.Text:
+          default:
+            return `"${strValue}"`;
         }
+      };
 
-        args[key] = shouldHaveQuotes ? `"${args[key]}"` : args[key];
-      }
+      args["input-1"] = formatValue(args["input-1"], input1Type);
+      args["input-2"] = formatValue(args["input-2"], input2Type);
 
       type SerializeFunction = (arg: string) => string;
 
@@ -107,13 +154,13 @@ export default class IfElse extends ComponentCode {
                     `;
 
       if (args["operator"] === ConditionOperator.Contains) {
-        code += `return input1.includes(input2);`;
+        code += `return String(input1).includes(String(input2));`;
       } else if (args["operator"] === ConditionOperator.DoesNotContain) {
-        code += `return !input1.includes(input2);`;
+        code += `return !String(input1).includes(String(input2));`;
       } else if (args["operator"] === ConditionOperator.StartsWith) {
-        code += `return input1.startsWith(input2);`;
+        code += `return String(input1).startsWith(String(input2));`;
       } else if (args["operator"] === ConditionOperator.EndsWith) {
-        code += `return input1.endsWith(input2);`;
+        code += `return String(input1).endsWith(String(input2));`;
       } else {
         code += `return input1 ${(args["operator"] as string) || "=="} input2;`;
       }

package/Server/Utils/Cookie.ts

@@ -12,6 +12,10 @@ import {
   MASTER_PASSWORD_COOKIE_IDENTIFIER,
   MASTER_PASSWORD_COOKIE_MAX_AGE_IN_DAYS,
 } from "../../Types/StatusPage/MasterPassword";
+import {
+  DASHBOARD_MASTER_PASSWORD_COOKIE_IDENTIFIER,
+  DASHBOARD_MASTER_PASSWORD_COOKIE_MAX_AGE_IN_DAYS,
+} from "../../Types/Dashboard/MasterPassword";
 import CaptureSpan from "./Telemetry/CaptureSpan";
 
 export default class CookieUtil {
@@ -323,6 +327,50 @@ export default class CookieUtil {
     );
   }
 
+  @CaptureSpan()
+  public static setDashboardMasterPasswordCookie(data: {
+    expressResponse: ExpressResponse;
+    dashboardId: ObjectID;
+  }): void {
+    const expiresInDays: PositiveNumber = new PositiveNumber(
+      DASHBOARD_MASTER_PASSWORD_COOKIE_MAX_AGE_IN_DAYS,
+    );
+
+    const token: string = JSONWebToken.signJsonPayload(
+      {
+        dashboardId: data.dashboardId.toString(),
+        type: DASHBOARD_MASTER_PASSWORD_COOKIE_IDENTIFIER,
+      },
+      OneUptimeDate.getSecondsInDays(expiresInDays),
+    );
+
+    CookieUtil.setCookie(
+      data.expressResponse,
+      CookieUtil.getDashboardMasterPasswordKey(data.dashboardId),
+      token,
+      {
+        maxAge: OneUptimeDate.getMillisecondsInDays(expiresInDays),
+        httpOnly: true,
+      },
+    );
+  }
+
+  @CaptureSpan()
+  public static removeDashboardMasterPasswordCookie(
+    res: ExpressResponse,
+    dashboardId: ObjectID,
+  ): void {
+    CookieUtil.removeCookie(
+      res,
+      CookieUtil.getDashboardMasterPasswordKey(dashboardId),
+    );
+  }
+
+  @CaptureSpan()
+  public static getDashboardMasterPasswordKey(id: ObjectID): string {
+    return `${CookieName.DashboardMasterPassword}-${id.toString()}`;
+  }
+
   // get all cookies with express request
   @CaptureSpan()
   public static getAllCookies(req: ExpressRequest): Dictionary<string> {

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

@@ -0,0 +1,34 @@
+import ProfileMonitorResponse from "../../../../Types/Monitor/ProfileMonitor/ProfileMonitorResponse";
+import CaptureSpan from "../../Telemetry/CaptureSpan";
+import DataToProcess from "../DataToProcess";
+import CompareCriteria from "./CompareCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+} from "../../../../Types/Monitor/CriteriaFilter";
+
+export default class ProfileMonitorCriteria {
+  @CaptureSpan()
+  public static async isMonitorInstanceCriteriaFilterMet(input: {
+    dataToProcess: DataToProcess;
+    criteriaFilter: CriteriaFilter;
+  }): Promise<string | null> {
+    let threshold: number | string | undefined | null =
+      input.criteriaFilter.value;
+
+    if (input.criteriaFilter.checkOn === CheckOn.ProfileCount) {
+      threshold = CompareCriteria.convertToNumber(threshold);
+
+      const currentProfileCount: number =
+        (input.dataToProcess as ProfileMonitorResponse).profileCount || 0;
+
+      return CompareCriteria.compareCriteriaNumbers({
+        value: currentProfileCount,
+        threshold: threshold as number,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    return null;
+  }
+}

package/Server/Utils/Monitor/DataToProcess.ts

@@ -6,6 +6,7 @@ import LogMonitorResponse from "../../../Types/Monitor/LogMonitor/LogMonitorResp
 import TraceMonitorResponse from "../../../Types/Monitor/TraceMonitor/TraceMonitorResponse";
 import MetricMonitorResponse from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
 import ExceptionMonitorResponse from "../../../Types/Monitor/ExceptionMonitor/ExceptionMonitorResponse";
+import ProfileMonitorResponse from "../../../Types/Monitor/ProfileMonitor/ProfileMonitorResponse";
 
 type DataToProcess =
   | ProbeMonitorResponse
@@ -15,6 +16,7 @@ type DataToProcess =
   | LogMonitorResponse
   | TraceMonitorResponse
   | MetricMonitorResponse
-  | ExceptionMonitorResponse;
+  | ExceptionMonitorResponse
+  | ProfileMonitorResponse;
 
 export default DataToProcess;