@oneuptime/common 7.0.3882 → 7.0.3899

package/Models/AnalyticsModels/TelemetryAttribute.ts

@@ -106,11 +106,11 @@ export default class TelemetryAttribute extends AnalyticsBaseModel {
         }),
 
         new AnalyticsTableColumn({
-          key: "attribute",
-          title: "Attribute",
-          description: "Attribute",
+          key: "attributes",
+          title: "Attributes",
+          description: "Attributes",
           required: true,
-          type: TableColumnType.Text,
+          type: TableColumnType.JSONArray,
           accessControl: {
             read: [
               Permission.ProjectOwner,
@@ -153,11 +153,11 @@ export default class TelemetryAttribute extends AnalyticsBaseModel {
     this.setColumnValue("telemetryType", v);
   }
 
-  public get attribute(): string | undefined {
-    return this.getColumnValue("attribute") as string | undefined;
+  public get attributes(): Array<string> | undefined {
+    return this.getColumnValue("attributes") as Array<string> | undefined;
   }
 
-  public set attribute(v: string | undefined) {
-    this.setColumnValue("attribute", v);
+  public set attributes(v: Array<string> | undefined) {
+    this.setColumnValue("attributes", v);
   }
 }

package/Server/API/TelemetryAPI.ts

@@ -11,7 +11,6 @@ import CommonAPI from "./CommonAPI";
 import DatabaseCommonInteractionProps from "Common/Types/BaseDatabase/DatabaseCommonInteractionProps";
 import TelemetryType from "Common/Types/Telemetry/TelemetryType";
 import TelemetryAttributeService from "../Services/TelemetryAttributeService";
-import ArrayUtil from "Common/Utils/Array";
 
 const router: ExpressRouter = Express.getRouter();
 
@@ -72,12 +71,11 @@ const getAttributes: GetAttributesFunction = async (
       );
     }
 
-    const attributes: string[] = ArrayUtil.removeDuplicates(
+    const attributes: string[] =
       await TelemetryAttributeService.fetchAttributes({
         projectId: databaseProps.tenantId,
         telemetryType,
-      }),
-    );
+      });
 
     return Response.sendJsonObjectResponse(req, res, {
       attributes: attributes,

package/Server/API/WorkspaceNotificationRuleAPI.ts

@@ -0,0 +1,48 @@
+import UserMiddleware from "../Middleware/UserAuthorization";
+import WorkspaceNotificationRuleService, {
+  Service as WorkspaceNotificationRuleServiceType,
+} from "../Services/WorkspaceNotificationRuleService";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import CommonAPI from "./CommonAPI";
+import DatabaseCommonInteractionProps from "Common/Types/BaseDatabase/DatabaseCommonInteractionProps";
+import WorkspaceNotificationRule from "Common/Models/DatabaseModels/WorkspaceNotificationRule";
+import ObjectID from "../../Types/ObjectID";
+
+export default class WorkspaceNotificationRuleAPI extends BaseAPI<
+  WorkspaceNotificationRule,
+  WorkspaceNotificationRuleServiceType
+> {
+  public constructor() {
+    super(WorkspaceNotificationRule, WorkspaceNotificationRuleService);
+
+    this.router.get(
+      `${new this.entityType().getCrudApiPath()?.toString()}/test/:workspaceNotifcationRuleId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const databaseProps: DatabaseCommonInteractionProps =
+            await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+          await this.service.testRule({
+            ruleId: new ObjectID(
+              req.params["workspaceNotifcationRuleId"] as string,
+            ),
+            props: databaseProps,
+            projectId: databaseProps.tenantId!,
+            testByUserId: databaseProps.userId!,
+          });
+
+          return Response.sendEmptySuccessResponse(req, res);
+        } catch (e) {
+          next(e);
+        }
+      },
+    );
+  }
+}

package/Server/Services/IncidentService.ts

@@ -302,7 +302,9 @@ export class Service extends DatabaseService<Model> {
       return 0;
     }
 
-    return lastIncident.incidentNumber || 0;
+    return lastIncident.incidentNumber
+      ? Number(lastIncident.incidentNumber)
+      : 0;
   }
 
   @CaptureSpan()

package/Server/Services/OpenTelemetryIngestService.ts

@@ -1,6 +1,5 @@
 import OneUptimeDate from "Common/Types/Date";
 import { JSONArray, JSONObject } from "Common/Types/JSON";
-import JSONFunctions from "Common/Types/JSONFunctions";
 import ObjectID from "Common/Types/ObjectID";
 import Metric, {
   AggregationTemporality,
@@ -166,21 +165,17 @@ export default class OTelIngestService {
       }
 
       newDbMetric.attributes = {
-        ...(newDbMetric.attributes || {}),
+        ...TelemetryUtil.getAttributesForServiceIdAndServiceName({
+          serviceId: data.telemetryServiceId,
+          serviceName: data.telemetryServiceName,
+        }),
         ...TelemetryUtil.getAttributes({
           items: datapoint["attributes"] as JSONArray,
-          telemetryServiceId: data.telemetryServiceId,
-          telemetryServiceName: data.telemetryServiceName,
+          prefixKeysWithString: "metricAttributes",
         }),
       };
     }
 
-    if (newDbMetric.attributes) {
-      newDbMetric.attributes = JSONFunctions.flattenObject(
-        newDbMetric.attributes,
-      );
-    }
-
     // aggregationTemporality
 
     if (aggregationTemporality) {

package/Server/Services/TelemetryAttributeService.ts

@@ -2,7 +2,6 @@ import TelemetryType from "../../Types/Telemetry/TelemetryType";
 import ClickhouseDatabase from "../Infrastructure/ClickhouseDatabase";
 import AnalyticsDatabaseService from "./AnalyticsDatabaseService";
 import TelemetryAttribute from "Common/Models/AnalyticsModels/TelemetryAttribute";
-import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
@@ -16,30 +15,24 @@ export class TelemetryAttributeService extends AnalyticsDatabaseService<Telemetr
     projectId: ObjectID;
     telemetryType: TelemetryType;
   }): Promise<string[]> {
-    const attributes: TelemetryAttribute[] = await this.findBy({
+    const telemetryAttribute: TelemetryAttribute | null = await this.findOneBy({
       query: {
         projectId: data.projectId,
         telemetryType: data.telemetryType,
       },
       select: {
-        attribute: true,
+        attributes: true,
       },
-      limit: LIMIT_PER_PROJECT,
-      skip: 0,
       props: {
         isRoot: true,
       },
     });
 
-    const dbAttributes: string[] = attributes
-      .map((attribute: TelemetryAttribute) => {
-        return attribute.attribute;
-      })
-      .filter((attribute: string | undefined) => {
-        return Boolean(attribute);
-      }) as string[];
-
-    return dbAttributes.sort();
+    return telemetryAttribute &&
+      telemetryAttribute.attributes &&
+      telemetryAttribute
+      ? telemetryAttribute.attributes
+      : [];
   }
 
   @CaptureSpan()
@@ -61,21 +54,14 @@ export class TelemetryAttributeService extends AnalyticsDatabaseService<Telemetr
       },
     });
 
-    const telemetryAttributes: TelemetryAttribute[] = [];
-
-    // insert new attributes
-    for (const attribute of attributes) {
-      const telemetryAttribute: TelemetryAttribute = new TelemetryAttribute();
-
-      telemetryAttribute.projectId = projectId;
-      telemetryAttribute.telemetryType = telemetryType;
-      telemetryAttribute.attribute = attribute;
+    const telemetryAttribute: TelemetryAttribute = new TelemetryAttribute();
 
-      telemetryAttributes.push(telemetryAttribute);
-    }
+    telemetryAttribute.projectId = projectId;
+    telemetryAttribute.telemetryType = telemetryType;
+    telemetryAttribute.attributes = attributes;
 
-    await this.createMany({
-      items: telemetryAttributes,
+    await this.create({
+      data: telemetryAttribute,
       props: {
         isRoot: true,
       },

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -38,6 +38,8 @@ import WorkspaceNotificationRule from "Common/Models/DatabaseModels/WorkspaceNot
 import UserService from "./UserService";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import Monitor from "../../Models/DatabaseModels/Monitor";
+import Text from "../../Types/Text";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 
 export interface MessageBlocksByWorkspaceType {
   workspaceType: WorkspaceType;
@@ -56,6 +58,209 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
     super(WorkspaceNotificationRule);
   }
 
+  @CaptureSpan()
+  public async testRule(data: {
+    ruleId: ObjectID;
+    projectId: ObjectID;
+    testByUserId: ObjectID; // this can be useful to invite user to channels if the channels was created.
+    props: DatabaseCommonInteractionProps;
+  }): Promise<void> {
+    const rule: WorkspaceNotificationRule | null = await this.findOneById({
+      id: data.ruleId,
+      select: {
+        notificationRule: true,
+        workspaceType: true,
+        eventType: true,
+        name: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!rule) {
+      throw new BadDataException("Rule not found");
+    }
+
+    // check fi the testUser account is connected to workspace or not.
+    const userWOrkspaceAuth: WorkspaceUserAuthToken | null =
+      await WorkspaceUserAuthTokenService.findOneBy({
+        query: {
+          projectId: data.projectId,
+          userId: data.testByUserId,
+          workspaceType: rule.workspaceType!,
+        },
+        select: {
+          workspaceUserId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!userWOrkspaceAuth || !userWOrkspaceAuth.workspaceUserId) {
+      throw new BadDataException(
+        "This account is not connected to " +
+          rule.workspaceType +
+          ". Please go to User Settings and connect the account.",
+      );
+    }
+
+    const projectAuth: WorkspaceProjectAuthToken | null =
+      await WorkspaceProjectAuthTokenService.findOneBy({
+        query: {
+          projectId: data.projectId,
+          workspaceType: rule.workspaceType!,
+        },
+        select: {
+          workspaceType: true,
+          authToken: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!projectAuth) {
+      throw new BadDataException(
+        "This project is not connected to " +
+          rule.workspaceType +
+          ". Please go to Project Settings and connect the account.",
+      );
+    }
+
+    const projectAuthToken: string = projectAuth.authToken!;
+
+    const notificationRule: BaseNotificationRule =
+      rule.notificationRule as BaseNotificationRule;
+
+    // now send test message to these channels.
+    const messageBlocksByWorkspaceTypes: Array<MessageBlocksByWorkspaceType> =
+      [];
+
+    // use markdown to create blocks
+    messageBlocksByWorkspaceTypes.push({
+      workspaceType: rule.workspaceType!,
+      messageBlocks: [
+        {
+          _type: "WorkspacePayloadMarkdown",
+          text: `This is a test message for rule **${rule.name}**`,
+        } as WorkspacePayloadMarkdown,
+      ],
+    });
+
+    let existingChannelNames: Array<string> = [];
+
+    let createdChannels: NotificationRuleWorkspaceChannel[] = [];
+
+    if ((notificationRule as IncidentNotificationRule).shouldCreateNewChannel) {
+      const generateRandomString: string = Text.generateRandomText(5);
+
+      try {
+        // create channel
+        createdChannels = await this.createChannelsBasedOnRules({
+          projectOrUserAuthTokenForWorkspace: projectAuthToken,
+          workspaceType: rule.workspaceType!,
+          notificationRules: [rule],
+          channelNameSiffix: generateRandomString,
+          notificationEventType: rule.eventType!,
+        });
+      } catch (err) {
+        throw new BadDataException(
+          "Cannot create a new channel. " + (err as Error)?.message,
+        );
+      }
+
+      try {
+        await this.inviteUsersBasedOnRulesAndWorkspaceChannels({
+          workspaceChannels: createdChannels,
+          projectId: data.projectId,
+          notificationRules: [rule],
+          userIds: [data.testByUserId],
+        });
+      } catch (err) {
+        throw new BadDataException(
+          "Cannot invite users to the channel. " + (err as Error)?.message,
+        );
+      }
+    }
+
+    if (notificationRule.shouldPostToExistingChannel) {
+      existingChannelNames = this.getExistingChannelNamesFromNotificationRules({
+        notificationRules: [notificationRule],
+      });
+
+      for (const channelName of existingChannelNames) {
+        try {
+          // check if these channels exist.
+          const channelExists: boolean =
+            await WorkspaceUtil.getWorkspaceTypeUtil(
+              rule.workspaceType!,
+            ).doesChannelExist({
+              authToken: projectAuthToken,
+              channelName: channelName,
+            });
+
+          if (!channelExists) {
+            throw new BadDataException(
+              `Channel ${channelName} does not exist.`,
+            );
+          }
+        } catch (err) {
+          throw new BadDataException((err as Error)?.message);
+        }
+      }
+
+      // post message
+
+      for (const createdChannel of createdChannels) {
+        try {
+          await WorkspaceUtil.postMessageToAllWorkspaceChannelsAsBot({
+            projectId: data.projectId,
+            messagePayloadsByWorkspace: messageBlocksByWorkspaceTypes.map(
+              (messageBlocksByWorkspaceType: MessageBlocksByWorkspaceType) => {
+                return {
+                  _type: "WorkspaceMessagePayload",
+                  workspaceType: messageBlocksByWorkspaceType.workspaceType,
+                  messageBlocks: messageBlocksByWorkspaceType.messageBlocks,
+                  channelNames: [],
+                  channelIds: [createdChannel.id],
+                };
+              },
+            ),
+          });
+        } catch (err) {
+          throw new BadDataException(
+            "Cannot post message to channel. " + (err as Error)?.message,
+          );
+        }
+      }
+
+      for (const existingChannelName of existingChannelNames) {
+        try {
+          await WorkspaceUtil.postMessageToAllWorkspaceChannelsAsBot({
+            projectId: data.projectId,
+            messagePayloadsByWorkspace: messageBlocksByWorkspaceTypes.map(
+              (messageBlocksByWorkspaceType: MessageBlocksByWorkspaceType) => {
+                return {
+                  _type: "WorkspaceMessagePayload",
+                  workspaceType: messageBlocksByWorkspaceType.workspaceType,
+                  messageBlocks: messageBlocksByWorkspaceType.messageBlocks,
+                  channelNames: [existingChannelName],
+                  channelIds: [],
+                };
+              },
+            ),
+          });
+        } catch (err) {
+          throw new BadDataException(
+            "Cannot post message to channel. " + (err as Error)?.message,
+          );
+        }
+      }
+    }
+  }
+
   @CaptureSpan()
   public async sendWorkspaceMarkdownNotification(data: {
     projectId: ObjectID;
@@ -103,6 +308,7 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
           projectId: data.projectId,
           notificationRuleEventType: NotificationRuleEventType.Monitor,
           workspaceType: messageBlocksByWorkspaceType.workspaceType,
+          notificationFor: data.notificationFor,
         });
 
       let monitorChannels: Array<WorkspaceChannel> = [];
@@ -198,15 +404,17 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
     projectId: ObjectID;
     workspaceType: WorkspaceType;
     notificationRuleEventType: NotificationRuleEventType;
+    notificationFor: NotificationFor;
   }): Promise<Array<string>> {
     logger.debug("getExistingChannelNamesBasedOnEventType called with data:");
     logger.debug(data);
 
     const notificationRules: Array<WorkspaceNotificationRule> =
-      await this.getNotificationRules({
+      await this.getMatchingNotificationRules({
         projectId: data.projectId,
         workspaceType: data.workspaceType,
         notificationRuleEventType: data.notificationRuleEventType,
+        notificationFor: data.notificationFor,
       });
 
     logger.debug("Notification rules retrieved:");

package/Server/Utils/Telemetry/CaptureSpan.ts

@@ -63,7 +63,13 @@ function CaptureSpan(data?: {
       return Telemetry.startActiveSpan({
         name: name,
         options: {
-          attributes: spanAttributes,
+          attributes: {
+            ...spanAttributes,
+            hey: "there",
+            thisIsNumber: 123,
+            thisIsBoolean: true,
+            thisIsArray: [1, 2, 3],
+          },
         },
         fn: (span: Span) => {
           let result: any = null;