@oneuptime/common 10.0.61 → 10.0.62

package/Server/API/TelemetryAPI.ts

@@ -1208,6 +1208,16 @@ router.post(
         ? (body["profileType"] as string)
         : undefined;
 
+      const profileTypes: Array<string> | undefined = Array.isArray(
+        body["profileTypes"],
+      )
+        ? (body["profileTypes"] as Array<string>).filter(
+            (t: unknown): t is string => {
+              return typeof t === "string" && t.length > 0;
+            },
+          )
+        : undefined;
+
       if (!profileId && !startTime) {
         return Response.sendErrorResponse(
           req,
@@ -1225,6 +1235,8 @@ router.post(
         ...(endTime !== undefined && { endTime }),
         ...(serviceIds !== undefined && { serviceIds }),
         ...(profileType !== undefined && { profileType }),
+        ...(profileTypes !== undefined &&
+          profileTypes.length > 0 && { profileTypes }),
       };
 
       const flamegraph: ProfileFlamegraphNode =
@@ -1281,6 +1293,16 @@ router.post(
         ? (body["profileType"] as string)
         : undefined;
 
+      const profileTypes: Array<string> | undefined = Array.isArray(
+        body["profileTypes"],
+      )
+        ? (body["profileTypes"] as Array<string>).filter(
+            (t: unknown): t is string => {
+              return typeof t === "string" && t.length > 0;
+            },
+          )
+        : undefined;
+
       const limit: number | undefined = body["limit"]
         ? (body["limit"] as number)
         : undefined;
@@ -1296,6 +1318,8 @@ router.post(
         endTime,
         ...(serviceIds !== undefined && { serviceIds }),
         ...(profileType !== undefined && { profileType }),
+        ...(profileTypes !== undefined &&
+          profileTypes.length > 0 && { profileTypes }),
         ...(limit !== undefined && { limit }),
         ...(sortBy !== undefined && { sortBy }),
       };
@@ -1506,6 +1530,16 @@ router.post(
         ? (body["profileType"] as string)
         : undefined;
 
+      const profileTypes: Array<string> | undefined = Array.isArray(
+        body["profileTypes"],
+      )
+        ? (body["profileTypes"] as Array<string>).filter(
+            (t: unknown): t is string => {
+              return typeof t === "string" && t.length > 0;
+            },
+          )
+        : undefined;
+
       const request: DiffFlamegraphRequest = {
         projectId: databaseProps.tenantId,
         baselineStartTime,
@@ -1514,6 +1548,8 @@ router.post(
         comparisonEndTime,
         ...(serviceIds !== undefined && { serviceIds }),
         ...(profileType !== undefined && { profileType }),
+        ...(profileTypes !== undefined &&
+          profileTypes.length > 0 && { profileTypes }),
       };
 
       const diffFlamegraph: DiffFlamegraphNode =

package/Server/Services/ProfileAggregationService.ts

@@ -26,7 +26,17 @@ export interface FlamegraphRequest {
   startTime?: Date;
   endTime?: Date;
   serviceIds?: Array<ObjectID>;
+  /**
+   * Single profile type to filter on. Kept for backwards compat. When
+   * `profileTypes` is also supplied, `profileTypes` wins.
+   */
   profileType?: string;
+  /**
+   * Multiple raw profile-type strings to OR together. The UI maps a
+   * user-facing category (e.g. "CPU") to all the raw type strings real
+   * agents actually emit (e.g. ["cpu", "samples"]).
+   */
+  profileTypes?: Array<string>;
 }
 
 export interface FunctionListItem {
@@ -44,6 +54,7 @@ export interface FunctionListRequest {
   endTime: Date;
   serviceIds?: Array<ObjectID>;
   profileType?: string;
+  profileTypes?: Array<string>;
   limit?: number;
   sortBy?: "selfValue" | "totalValue" | "sampleCount";
 }
@@ -56,6 +67,7 @@ export interface DiffFlamegraphRequest {
   comparisonEndTime: Date;
   serviceIds?: Array<ObjectID>;
   profileType?: string;
+  profileTypes?: Array<string>;
 }
 
 export interface DiffFlamegraphNode {
@@ -302,6 +314,9 @@ export class ProfileAggregationService {
         ...(request.profileType !== undefined && {
           profileType: request.profileType,
         }),
+        ...(request.profileTypes !== undefined && {
+          profileTypes: request.profileTypes,
+        }),
       });
 
     const comparisonTree: ProfileFlamegraphNode =
@@ -315,6 +330,9 @@ export class ProfileAggregationService {
         ...(request.profileType !== undefined && {
           profileType: request.profileType,
         }),
+        ...(request.profileTypes !== undefined && {
+          profileTypes: request.profileTypes,
+        }),
       });
 
     return ProfileAggregationService.mergeDiffTrees(
@@ -490,7 +508,10 @@ export class ProfileAggregationService {
 
   private static appendCommonFilters(
     statement: Statement,
-    request: Pick<FlamegraphRequest, "serviceIds" | "profileType">,
+    request: Pick<
+      FlamegraphRequest,
+      "serviceIds" | "profileType" | "profileTypes"
+    >,
   ): void {
     if (request.serviceIds && request.serviceIds.length > 0) {
       statement.append(
@@ -505,7 +526,18 @@ export class ProfileAggregationService {
       );
     }
 
-    if (request.profileType) {
+    /*
+     * profileTypes (array) wins over profileType (single) so the UI can
+     * OR together every raw type string in a category.
+     */
+    if (request.profileTypes && request.profileTypes.length > 0) {
+      statement.append(
+        SQL` AND profileType IN (${{
+          type: TableColumnType.Text,
+          value: new Includes(request.profileTypes),
+        }})`,
+      );
+    } else if (request.profileType) {
       statement.append(
         SQL` AND profileType = ${{
           type: TableColumnType.Text,

package/Server/Types/Workflow/ComponentCode.ts

@@ -9,12 +9,30 @@ import ObjectID from "../../../Types/ObjectID";
 import ComponentMetadata, { Port } from "../../../Types/Workflow/Component";
 import CaptureSpan from "../../Utils/Telemetry/CaptureSpan";
 
+export interface ExecuteChildWorkflow {
+  workflowId: ObjectID;
+  returnValues: JSONObject;
+}
+
+/**
+ * Maximum depth of nested workflow invocations (Execute Workflow component).
+ * Catches pathological fanout even when no direct cycle exists.
+ */
+export const MAX_WORKFLOW_CALL_DEPTH: number = 10;
+
 export interface RunOptions {
   log: (item: string | JSONObject | Error | JSONArray | JSONValue) => void;
   workflowLogId: ObjectID;
   workflowId: ObjectID;
   projectId: ObjectID;
   onError: (exception: Exception) => Exception;
+  /**
+   * Fire-and-forget trigger for another workflow in the same project.
+   * Enqueues the target workflow with the given `returnValues` as its arguments
+   * (the payload a Manual trigger in the child workflow will receive on its
+   * output port).
+   */
+  executeWorkflow: (executeWorkflow: ExecuteChildWorkflow) => Promise<void>;
 }
 
 export interface RunReturnType {

package/Server/Types/Workflow/Components/Index.ts

@@ -30,6 +30,7 @@ import Schedule from "./Schedule";
 import SlackSendMessageToChannel from "./Slack/SendMessageToChannel";
 import TelegramSendMessageToChat from "./Telegram/SendMessageToChat";
 import WebhookTrigger from "./Webhook";
+import ExecuteWorkflow from "./Workflow";
 import BaseModel from "../../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import Dictionary from "../../../../Types/Dictionary";
 import Text from "../../../../Types/Text";
@@ -57,6 +58,7 @@ const Components: Dictionary<ComponentCode> = {
   [ComponentID.ApiPut]: new ApiPut(),
   [ComponentID.SendEmail]: new Email(),
   [ComponentID.IfElse]: new IfElse(),
+  [ComponentID.WorkflowRun]: new ExecuteWorkflow(),
 };
 
 for (const baseModelService of Services) {

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

@@ -0,0 +1,129 @@
+import ComponentCode, { RunOptions, RunReturnType } from "../ComponentCode";
+import BadDataException from "../../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../../Types/JSON";
+import ObjectID from "../../../../Types/ObjectID";
+import ComponentMetadata, { Port } from "../../../../Types/Workflow/Component";
+import ComponentID from "../../../../Types/Workflow/ComponentID";
+import WorkflowComponents from "../../../../Types/Workflow/Components/Workflow";
+import CaptureSpan from "../../../Utils/Telemetry/CaptureSpan";
+
+export default class ExecuteWorkflow extends ComponentCode {
+  public constructor() {
+    super();
+
+    const Component: ComponentMetadata | undefined = WorkflowComponents.find(
+      (i: ComponentMetadata) => {
+        return i.id === ComponentID.WorkflowRun;
+      },
+    );
+
+    if (!Component) {
+      throw new BadDataException("Execute Workflow component not found.");
+    }
+
+    this.setMetadata(Component);
+  }
+
+  @CaptureSpan()
+  public override async run(
+    args: JSONObject,
+    options: RunOptions,
+  ): Promise<RunReturnType> {
+    const successPort: Port | undefined = this.getMetadata().outPorts.find(
+      (p: Port) => {
+        return p.id === "out";
+      },
+    );
+
+    const errorPort: Port | undefined = this.getMetadata().outPorts.find(
+      (p: Port) => {
+        return p.id === "error";
+      },
+    );
+
+    if (!successPort) {
+      throw options.onError(new BadDataException("Out port not found"));
+    }
+
+    if (!errorPort) {
+      throw options.onError(new BadDataException("Error port not found"));
+    }
+
+    try {
+      const workflowIdString: string | undefined = args["workflowId"] as
+        | string
+        | undefined;
+
+      if (!workflowIdString) {
+        throw new BadDataException("Workflow ID is required.");
+      }
+
+      if (!ObjectID.isValidUUID(workflowIdString)) {
+        throw new BadDataException(
+          "Workflow ID is not a valid ObjectID: " + workflowIdString,
+        );
+      }
+
+      const targetWorkflowId: ObjectID = new ObjectID(workflowIdString);
+
+      // Prevent a workflow from triggering itself — obvious infinite loop.
+      if (targetWorkflowId.toString() === options.workflowId.toString()) {
+        throw new BadDataException(
+          "A workflow cannot execute itself. Use a different workflow ID.",
+        );
+      }
+
+      let payload: JSONObject = {};
+      const rawArgs: unknown = args["arguments"];
+
+      if (rawArgs) {
+        if (typeof rawArgs === "object") {
+          payload = rawArgs as JSONObject;
+        } else if (typeof rawArgs === "string") {
+          try {
+            payload = JSON.parse(rawArgs) as JSONObject;
+          } catch (err: unknown) {
+            throw new BadDataException(
+              "Arguments must be valid JSON: " +
+                (err instanceof Error ? err.message : String(err)),
+            );
+          }
+        } else {
+          throw new BadDataException(
+            "Arguments must be a JSON object or a JSON string.",
+          );
+        }
+      }
+
+      options.log("Enqueuing child workflow " + targetWorkflowId.toString());
+      options.log("Payload:");
+      options.log(payload);
+
+      await options.executeWorkflow({
+        workflowId: targetWorkflowId,
+        returnValues: payload,
+      });
+
+      options.log(
+        "Child workflow " +
+          targetWorkflowId.toString() +
+          " enqueued successfully.",
+      );
+
+      return {
+        returnValues: {},
+        executePort: successPort,
+      };
+    } catch (err: unknown) {
+      const message: string = err instanceof Error ? err.message : String(err);
+      options.log("Failed to execute child workflow: " + message);
+
+      return {
+        returnValues: {
+          error: message,
+        },
+        executePort: errorPort,
+      };
+    }
+  }
+}

package/Server/Types/Workflow/TriggerCode.ts

@@ -13,6 +13,13 @@ import CaptureSpan from "../../Utils/Telemetry/CaptureSpan";
 export interface ExecuteWorkflowType {
   workflowId: ObjectID;
   returnValues: JSONObject;
+  /**
+   * Chain of ancestor workflow IDs (oldest first). Set when one workflow
+   * invokes another via the Execute Workflow component so downstream runs
+   * can detect cycles. Top-level triggers (webhook, manual API, schedule)
+   * should leave this undefined.
+   */
+  callChain?: Array<string>;
 }
 
 export interface InitProps {

package/Server/Types/Workflow/Workflow.ts

@@ -6,4 +6,11 @@ export interface RunProps {
   workflowId: ObjectID;
   workflowLogId: ObjectID | null;
   timeout: number;
+  /**
+   * Chain of ancestor workflow IDs that led to this run, oldest first.
+   * Empty / undefined for top-level runs. Used by the Execute Workflow
+   * component to detect cycles (A -> B -> A) and enforce a max recursion
+   * depth across workflow boundaries.
+   */
+  callChain?: Array<string>;
 }

package/Types/Workflow/Component.ts

@@ -27,6 +27,7 @@ export enum ComponentInputType {
   Operator = "Operator",
   Markdown = "Markdown",
   ValueType = "Value Type",
+  WorkflowSelect = "Workflow Select",
 }
 
 export enum ComponentType {

package/Types/Workflow/ComponentID.ts

@@ -18,6 +18,7 @@ enum ComponentID {
   ApiPatch = "api-patch",
   SendEmail = "send-email",
   IfElse = "if-else",
+  WorkflowRun = "workflow-run",
 }
 
 export default ComponentID;

package/Types/Workflow/Components/Workflow.ts

@@ -1,4 +1,5 @@
 import IconProp from "../../Icon/IconProp";
+import ComponentID from "../ComponentID";
 import ComponentMetadata, {
   ComponentInputType,
   ComponentType,
@@ -6,19 +7,31 @@ import ComponentMetadata, {
 
 const components: Array<ComponentMetadata> = [
   {
-    id: "workflow-run",
+    id: ComponentID.WorkflowRun,
     title: "Execute Workflow",
     category: "Utils",
-    description: "Execute another workflow",
+    description:
+      "Execute another workflow in the same project (fire-and-forget)",
     iconProp: IconProp.Workflow,
     componentType: ComponentType.Component,
     arguments: [
       {
-        type: ComponentInputType.AnyValue,
-        name: "Value",
-        description: "Value to pass to another workflow",
+        type: ComponentInputType.WorkflowSelect,
+        name: "Workflow",
+        description:
+          "Pick the workflow to execute. The workflow must be in the same project and be enabled. It must have a Manual trigger to receive the arguments passed below.",
+        required: true,
+        id: "workflowId",
+        placeholder: "Select a workflow",
+      },
+      {
+        type: ComponentInputType.JSON,
+        name: "Arguments",
+        description:
+          "JSON payload to pass to the target workflow. The target workflow's Manual trigger will emit this object on its output port.",
         required: false,
-        id: "value",
+        id: "arguments",
+        placeholder: '{ "key": "value" }',
       },
     ],
     returnValues: [],
@@ -34,9 +47,15 @@ const components: Array<ComponentMetadata> = [
       {
         title: "Out",
         description:
-          "Connect to this port if you want other components to execute after the workflow is triggered",
+          "Connect to this port if you want other components to execute after the workflow is triggered. This component is fire-and-forget — it does not wait for the child workflow to finish.",
         id: "out",
       },
+      {
+        title: "Error",
+        description:
+          "Executes if the child workflow could not be enqueued (e.g. not found, disabled, or in a different project).",
+        id: "error",
+      },
     ],
   },
 ];

package/UI/Components/Workflow/ArgumentsForm.tsx

@@ -1,3 +1,4 @@
+import ComponentLoader from "../ComponentLoader/ComponentLoader";
 import ErrorMessage from "../ErrorMessage/ErrorMessage";
 import BasicForm, { FormProps } from "../Forms/BasicForm";
 import FormValues from "../Forms/Types/FormValues";
@@ -7,7 +8,15 @@ import VariableModal from "./VariableModal";
 import Dictionary from "../../../Types/Dictionary";
 import { JSONObject } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
-import { Argument, NodeDataProp } from "../../../Types/Workflow/Component";
+import {
+  Argument,
+  ComponentInputType,
+  NodeDataProp,
+} from "../../../Types/Workflow/Component";
+import { DropdownOption } from "../Dropdown/Dropdown";
+import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
+import ModelAPI, { ListResult } from "../../Utils/ModelAPI/ModelAPI";
+import Workflow from "../../../Models/DatabaseModels/Workflow";
 import React, {
   FunctionComponent,
   ReactElement,
@@ -40,6 +49,88 @@ const ArgumentsForm: FunctionComponent<ComponentProps> = (
 
   const [selectedArgId, setSelectedArgId] = useState<string>("");
 
+  /*
+   * Workflows in the current project, used to populate dropdowns for any
+   * argument of type WorkflowSelect (e.g. the "Workflow" field on the
+   * Execute Workflow component). Empty until the fetch completes.
+   */
+  const [workflowDropdownOptions, setWorkflowDropdownOptions] = useState<
+    Array<DropdownOption>
+  >([]);
+  const [isLoadingWorkflows, setIsLoadingWorkflows] = useState<boolean>(false);
+
+  const hasWorkflowSelectArg: boolean = Boolean(
+    component.metadata.arguments?.some((arg: Argument) => {
+      return arg.type === ComponentInputType.WorkflowSelect;
+    }),
+  );
+
+  useEffect(() => {
+    if (!hasWorkflowSelectArg) {
+      return;
+    }
+
+    let cancelled: boolean = false;
+    setIsLoadingWorkflows(true);
+
+    const loadWorkflows: () => Promise<void> = async (): Promise<void> => {
+      try {
+        const result: ListResult<Workflow> = await ModelAPI.getList<Workflow>({
+          modelType: Workflow,
+          query: {},
+          limit: LIMIT_PER_PROJECT,
+          skip: 0,
+          select: {
+            _id: true,
+            name: true,
+          },
+          sort: {
+            name: "Ascending" as any,
+          },
+        });
+
+        if (cancelled) {
+          return;
+        }
+
+        const currentWorkflowIdStr: string = props.workflowId.toString();
+
+        const options: Array<DropdownOption> = result.data
+          .filter((wf: Workflow) => {
+            // Exclude the current workflow — can't pick yourself.
+            return wf._id?.toString() !== currentWorkflowIdStr;
+          })
+          .map((wf: Workflow) => {
+            return {
+              label: (wf.name as string) || (wf._id?.toString() ?? ""),
+              value: wf._id?.toString() ?? "",
+            };
+          });
+
+        setWorkflowDropdownOptions(options);
+      } catch {
+        /*
+         * Swallow: the dropdown will simply be empty and the user can try
+         * again by re-opening the settings panel.
+         */
+        if (!cancelled) {
+          setWorkflowDropdownOptions([]);
+        }
+      } finally {
+        if (!cancelled) {
+          setIsLoadingWorkflows(false);
+        }
+      }
+    };
+
+    void loadWorkflows();
+
+    return () => {
+      cancelled = true;
+    };
+    // Only re-fetch when the component in the settings panel changes identity.
+  }, [component.id, hasWorkflowSelectArg]);
+
   useEffect(() => {
     props.onHasFormValidationErrors(hasFormValidationErrors);
   }, [hasFormValidationErrors]);
@@ -61,8 +152,15 @@ const ArgumentsForm: FunctionComponent<ComponentProps> = (
               message={"This component does not take any arguments."}
             />
           )}
+        {/*
+          If any argument is a WorkflowSelect and we're still fetching the
+          list of workflows, show a loader instead of the form. Otherwise
+          the user briefly sees an empty dropdown which is confusing.
+        */}
+        {hasWorkflowSelectArg && isLoadingWorkflows && <ComponentLoader />}
         {component.metadata.arguments &&
-          component.metadata.arguments.length > 0 && (
+          component.metadata.arguments.length > 0 &&
+          !(hasWorkflowSelectArg && isLoadingWorkflows) && (
             <BasicForm
               hideSubmitButton={true}
               ref={formRef}
@@ -89,9 +187,34 @@ const ArgumentsForm: FunctionComponent<ComponentProps> = (
               fields={
                 component.metadata.arguments &&
                 component.metadata.arguments.map((arg: Argument) => {
+                  const isWorkflowSelect: boolean =
+                    arg.type === ComponentInputType.WorkflowSelect;
+
+                  const baseField: {
+                    fieldType: import("../Forms/Types/FormFieldSchemaType").default;
+                    dropdownOptions?: Array<DropdownOption> | undefined;
+                  } = componentInputTypeToFormFieldType(
+                    arg.type,
+                    component.arguments && component.arguments[arg.id]
+                      ? component.arguments[arg.id]
+                      : null,
+                  );
+
+                  /*
+                   * For WorkflowSelect, inject the dynamically fetched list
+                   * of workflows as dropdown options.
+                   */
+                  if (isWorkflowSelect) {
+                    baseField.dropdownOptions = workflowDropdownOptions;
+                  }
+
                   return {
                     title: `${arg.name}`,
-                    footerElement: (
+                    /*
+                     * WorkflowSelect has no "pick from component/variable"
+                     * footer — it's a bound dropdown, not a free-text field.
+                     */
+                    footerElement: isWorkflowSelect ? undefined : (
                       <div className="text-gray-500">
                         <p className="text-sm">
                           Pick this value from other{" "}
@@ -125,12 +248,7 @@ const ArgumentsForm: FunctionComponent<ComponentProps> = (
                     },
                     required: arg.required,
                     placeholder: arg.placeholder,
-                    ...componentInputTypeToFormFieldType(
-                      arg.type,
-                      component.arguments && component.arguments[arg.id]
-                        ? component.arguments[arg.id]
-                        : null,
-                    ),
+                    ...baseField,
                   };
                 })
               }

package/UI/Components/Workflow/Utils.ts

@@ -233,6 +233,17 @@ export const componentInputTypeToFormFieldType: ComponentInputTypeToFormFieldTyp
       };
     }
 
+    if (componentInputType === ComponentInputType.WorkflowSelect) {
+      /*
+       * Dropdown options are injected at render time by ArgumentsForm,
+       * which fetches the list of workflows in the current project.
+       */
+      return {
+        fieldType: FormFieldSchemaType.Dropdown,
+        dropdownOptions: [],
+      };
+    }
+
     if (componentInputType === ComponentInputType.ValueType) {
       return {
         fieldType: FormFieldSchemaType.Dropdown,