@oneuptime/common 10.0.51 → 10.0.53

package/Server/API/TelemetryAPI.ts

@@ -54,6 +54,14 @@ router.post(
   },
 );
 
+router.post(
+  "/telemetry/metrics/get-attribute-values",
+  UserMiddleware.getUserMiddleware,
+  async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+    return getAttributeValues(req, res, next, TelemetryType.Metric);
+  },
+);
+
 router.post(
   "/telemetry/logs/get-attributes",
   UserMiddleware.getUserMiddleware,
@@ -103,10 +111,16 @@ const getAttributes: GetAttributesFunction = async (
       );
     }
 
+    const metricName: string | undefined =
+      req.body["metricName"] && typeof req.body["metricName"] === "string"
+        ? (req.body["metricName"] as string)
+        : undefined;
+
     const attributes: string[] =
       await TelemetryAttributeService.fetchAttributes({
         projectId: databaseProps.tenantId,
         telemetryType,
+        metricName,
       });
 
     return Response.sendJsonObjectResponse(req, res, {
@@ -117,6 +131,73 @@ const getAttributes: GetAttributesFunction = async (
   }
 };
 
+type GetAttributeValuesFunction = (
+  req: ExpressRequest,
+  res: ExpressResponse,
+  next: NextFunction,
+  telemetryType: TelemetryType,
+) => Promise<void>;
+
+const getAttributeValues: GetAttributeValuesFunction = async (
+  req: ExpressRequest,
+  res: ExpressResponse,
+  next: NextFunction,
+  telemetryType: TelemetryType,
+) => {
+  try {
+    const databaseProps: DatabaseCommonInteractionProps =
+      await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+    if (!databaseProps) {
+      return Response.sendErrorResponse(
+        req,
+        res,
+        new BadDataException("Invalid User Session"),
+      );
+    }
+
+    if (!databaseProps.tenantId) {
+      return Response.sendErrorResponse(
+        req,
+        res,
+        new BadDataException("Invalid Project ID"),
+      );
+    }
+
+    const attributeKey: string | undefined =
+      req.body["attributeKey"] && typeof req.body["attributeKey"] === "string"
+        ? (req.body["attributeKey"] as string)
+        : undefined;
+
+    if (!attributeKey) {
+      return Response.sendErrorResponse(
+        req,
+        res,
+        new BadDataException("attributeKey is required"),
+      );
+    }
+
+    const metricName: string | undefined =
+      req.body["metricName"] && typeof req.body["metricName"] === "string"
+        ? (req.body["metricName"] as string)
+        : undefined;
+
+    const values: string[] =
+      await TelemetryAttributeService.fetchAttributeValues({
+        projectId: databaseProps.tenantId,
+        telemetryType,
+        metricName,
+        attributeKey,
+      });
+
+    return Response.sendJsonObjectResponse(req, res, {
+      values: values,
+    });
+  } catch (err: any) {
+    next(err);
+  }
+};
+
 // --- Log Histogram Endpoint ---
 
 router.post(

package/Server/Services/LabelService.ts

@@ -3,6 +3,7 @@ import { OnCreate } from "../Types/Database/Hooks";
 import QueryHelper from "../Types/Database/QueryHelper";
 import DatabaseService from "./DatabaseService";
 import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
 import Model from "../../Models/DatabaseModels/Label";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 export class Service extends DatabaseService<Model> {
@@ -14,13 +15,25 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeCreate(
     createBy: CreateBy<Model>,
   ): Promise<OnCreate<Model>> {
+    let projectId: ObjectID | undefined = createBy.props.tenantId;
+
+    if (createBy.props.isMasterAdmin || createBy.props.isRoot) {
+      if (createBy.data.projectId) {
+        projectId = createBy.data.projectId;
+      }
+    }
+
+    if (!projectId) {
+      throw new BadDataException("Project ID is required to create a label.");
+    }
+
     let existingProjectWithSameNameCount: number = 0;
 
     existingProjectWithSameNameCount = (
       await this.countBy({
         query: {
           name: QueryHelper.findWithSameText(createBy.data.name!),
-          projectId: createBy.props.tenantId!,
+          projectId: projectId,
         },
         props: {
           isRoot: true,

package/Server/Services/MonitorProbeService.ts

@@ -5,9 +5,11 @@ import DatabaseService, { EntityManager } from "./DatabaseService";
 import OneUptimeDate from "../../Types/Date";
 import BadDataException from "../../Types/Exception/BadDataException";
 import MonitorProbe from "../../Models/DatabaseModels/MonitorProbe";
+import Monitor from "../../Models/DatabaseModels/Monitor";
 import QueryHelper from "../Types/Database/QueryHelper";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import MonitorService from "./MonitorService";
+import { MonitorTypeHelper } from "../../Types/Monitor/MonitorType";
 import CronTab from "../Utils/CronTab";
 import logger from "../Utils/Logger";
 
@@ -189,6 +191,31 @@ export class Service extends DatabaseService<MonitorProbe> {
       }
     }
 
+    // Check if the monitor type supports probes
+    const monitorId: ObjectID | undefined | null =
+      createBy.data.monitorId || createBy.data.monitor?.id;
+
+    if (monitorId) {
+      const monitor: Monitor | null = await MonitorService.findOneById({
+        id: monitorId,
+        select: {
+          monitorType: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (
+        monitor?.monitorType &&
+        !MonitorTypeHelper.isProbableMonitor(monitor.monitorType)
+      ) {
+        throw new BadDataException(
+          "Probes cannot be added to this monitor type.",
+        );
+      }
+    }
+
     if (!createBy.data.nextPingAt) {
       createBy.data.nextPingAt = OneUptimeDate.getCurrentDate();
     }

package/Server/Services/ProjectService.ts

@@ -1294,11 +1294,15 @@ export class ProjectService extends DatabaseService<Model> {
   protected override async onBeforeFind(
     findBy: FindBy<Model>,
   ): Promise<OnFind<Model>> {
-    // if user has no project id, then he should not be able to access any project.
+    /*
+     * if user has no project id, then he should not be able to access any project.
+     * Master admins should be able to access all projects.
+     */
     if (
-      (!findBy.props.isRoot &&
-        !findBy.props.userGlobalAccessPermission?.projectIds) ||
-      findBy.props.userGlobalAccessPermission?.projectIds.length === 0
+      !findBy.props.isRoot &&
+      !findBy.props.isMasterAdmin &&
+      (!findBy.props.userGlobalAccessPermission?.projectIds ||
+        findBy.props.userGlobalAccessPermission?.projectIds.length === 0)
     ) {
       findBy.props.isRoot = true;
       findBy.query._id = ObjectID.getZeroObjectID().toString(); // should not get any projects.

package/Server/Services/TelemetryAttributeService.ts

@@ -71,6 +71,7 @@ export class TelemetryAttributeService {
   public async fetchAttributes(data: {
     projectId: ObjectID;
     telemetryType: TelemetryType;
+    metricName?: string | undefined;
   }): Promise<string[]> {
     const source: TelemetrySource | null = this.getTelemetrySource(
       data.telemetryType,
@@ -83,6 +84,7 @@ export class TelemetryAttributeService {
     const cacheKey: string = TelemetryAttributeService.getCacheKey(
       data.projectId,
       data.telemetryType,
+      data.metricName,
     );
 
     const cachedEntry: TelemetryAttributesCacheEntry | null =
@@ -98,6 +100,7 @@ export class TelemetryAttributeService {
       attributes = await TelemetryAttributeService.fetchAttributesFromDatabase({
         projectId: data.projectId,
         source,
+        metricName: data.metricName,
       });
     } catch (error) {
       if (cachedEntry) {
@@ -122,8 +125,13 @@ export class TelemetryAttributeService {
   private static getCacheKey(
     projectId: ObjectID,
     telemetryType: TelemetryType,
+    metricName?: string | undefined,
   ): string {
-    return `${projectId.toString()}:${telemetryType}`;
+    const base: string = `${projectId.toString()}:${telemetryType}`;
+    if (metricName) {
+      return `${base}:${metricName}`;
+    }
+    return base;
   }
 
   private static getLookbackStartDate(): Date {
@@ -219,6 +227,7 @@ export class TelemetryAttributeService {
     attributesColumn: string;
     attributeKeysColumn: string;
     timeColumn: string;
+    metricName?: string | undefined;
   }): Statement {
     const lookbackStartDate: Date =
       TelemetryAttributeService.getLookbackStartDate();
@@ -244,7 +253,20 @@ export class TelemetryAttributeService {
           AND ${data.timeColumn} >= ${{
             type: TableColumnType.Date,
             value: lookbackStartDate,
-          }}
+          }}`;
+
+    if (data.metricName) {
+      statement.append(
+        SQL`
+          AND name = ${{
+            type: TableColumnType.Text,
+            value: data.metricName,
+          }}`,
+      );
+    }
+
+    statement.append(
+      SQL`
         ORDER BY ${data.timeColumn} DESC
         LIMIT ${{
           type: TableColumnType.Number,
@@ -258,8 +280,8 @@ export class TelemetryAttributeService {
       LIMIT ${{
         type: TableColumnType.Number,
         value: TelemetryAttributeService.ATTRIBUTES_LIMIT,
-      }}
-    `;
+      }}`,
+    );
 
     return statement;
   }
@@ -267,6 +289,7 @@ export class TelemetryAttributeService {
   private static async fetchAttributesFromDatabase(data: {
     projectId: ObjectID;
     source: TelemetrySource;
+    metricName?: string | undefined;
   }): Promise<Array<string>> {
     const statement: Statement =
       TelemetryAttributeService.buildAttributesStatement({
@@ -275,6 +298,7 @@ export class TelemetryAttributeService {
         attributesColumn: data.source.attributesColumn,
         attributeKeysColumn: data.source.attributeKeysColumn,
         timeColumn: data.source.timeColumn,
+        metricName: data.metricName,
       });
 
     const dbResult: Results = await data.source.service.executeQuery(statement);
@@ -295,6 +319,95 @@ export class TelemetryAttributeService {
 
     return Array.from(new Set(attributeKeys));
   }
+
+  private static readonly ATTRIBUTE_VALUES_LIMIT: number = 100;
+
+  @CaptureSpan()
+  public async fetchAttributeValues(data: {
+    projectId: ObjectID;
+    telemetryType: TelemetryType;
+    metricName?: string | undefined;
+    attributeKey: string;
+  }): Promise<string[]> {
+    const source: TelemetrySource | null = this.getTelemetrySource(
+      data.telemetryType,
+    );
+
+    if (!source) {
+      return [];
+    }
+
+    return TelemetryAttributeService.fetchAttributeValuesFromDatabase({
+      projectId: data.projectId,
+      source,
+      metricName: data.metricName,
+      attributeKey: data.attributeKey,
+    });
+  }
+
+  private static async fetchAttributeValuesFromDatabase(data: {
+    projectId: ObjectID;
+    source: TelemetrySource;
+    metricName?: string | undefined;
+    attributeKey: string;
+  }): Promise<Array<string>> {
+    const lookbackStartDate: Date =
+      TelemetryAttributeService.getLookbackStartDate();
+
+    const statement: Statement = SQL`
+      SELECT DISTINCT ${data.source.attributesColumn}[${{
+        type: TableColumnType.Text,
+        value: data.attributeKey,
+      }}] AS attributeValue
+      FROM ${data.source.tableName}
+      WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: data.projectId,
+      }}
+        AND ${data.source.timeColumn} >= ${{
+          type: TableColumnType.Date,
+          value: lookbackStartDate,
+        }}
+        AND mapContains(${data.source.attributesColumn}, ${{
+          type: TableColumnType.Text,
+          value: data.attributeKey,
+        }})`;
+
+    if (data.metricName) {
+      statement.append(
+        SQL`
+        AND name = ${{
+          type: TableColumnType.Text,
+          value: data.metricName,
+        }}`,
+      );
+    }
+
+    statement.append(
+      SQL`
+      ORDER BY attributeValue ASC
+      LIMIT ${{
+        type: TableColumnType.Number,
+        value: TelemetryAttributeService.ATTRIBUTE_VALUES_LIMIT,
+      }}`,
+    );
+
+    const dbResult: Results = await data.source.service.executeQuery(statement);
+    const response: DbJSONResponse = await dbResult.json<{
+      data?: Array<JSONObject>;
+    }>();
+
+    const rows: Array<JSONObject> = response.data || [];
+
+    return rows
+      .map((row: JSONObject) => {
+        const val: unknown = row["attributeValue"];
+        return typeof val === "string" ? val.trim() : null;
+      })
+      .filter((val: string | null): val is string => {
+        return Boolean(val);
+      });
+  }
 }
 
 export default new TelemetryAttributeService();

package/Server/Utils/StartServer.ts

@@ -266,14 +266,13 @@ const init: InitFunction = async (
       },
     );
 
-    // Return 404 for missing static assets instead of falling through to SPA catch-all.
-    // Without this, missing JS/CSS chunks get served as HTML (index.ejs),
-    // which causes "Failed to fetch dynamically imported module" errors.
+    /*
+     * Return 404 for missing static assets instead of falling through to SPA catch-all.
+     * Without this, missing JS/CSS chunks get served as HTML (index.ejs),
+     * which causes "Failed to fetch dynamically imported module" errors.
+     */
     app.get(
-      [
-        `/${appName}/dist/*`,
-        `/${appName}/assets/*`,
-      ],
+      [`/${appName}/dist/*`, `/${appName}/assets/*`],
       (_req: ExpressRequest, res: ExpressResponse) => {
         res.status(404).send("Not found");
       },

package/UI/Components/BulkUpdate/BulkUpdateForm.tsx

@@ -6,7 +6,6 @@ import ConfirmModal, {
 } from "../Modal/ConfirmModal";
 import ProgressBar, { ProgressBarSize } from "../ProgressBar/ProgressBar";
 import ShortcutKey from "../ShortcutKey/ShortcutKey";
-import SimpleLogViewer from "../SimpleLogViewer/SimpleLogViewer";
 import { Green, Red } from "../../../Types/BrandColors";
 import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
 import GenericObject from "../../../Types/GenericObject";
@@ -83,8 +82,6 @@ const BulkUpdateForm: <T extends GenericObject>(
   const [actionInProgress, setActionInProgress] =
     React.useState<boolean>(false);
 
-  const [actionName, setActionName] = React.useState<string>("");
-
   if (props.selectedItems.length === 0) {
     return <></>;
   }
@@ -102,44 +99,71 @@ const BulkUpdateForm: <T extends GenericObject>(
     }
 
     if (!actionInProgress && progressInfo) {
+      const hasFailures: boolean = progressInfo.failed.length > 0;
+      const hasSuccesses: boolean = progressInfo.successItems.length > 0;
+
       return (
-        <div className="mt-1 mb-1 space-y-1">
-          <div className="flex">
-            <Icon
-              className="h-5 w-5"
-              icon={IconProp.CheckCircle}
-              color={Green}
-            />
-            <div className="ml-1 font-medium">
-              {progressInfo.successItems.length} {props.pluralLabel} Succeeded
-            </div>
-          </div>
-          {progressInfo.failed.length > 0 && (
-            <div>
-              <div className="flex mt-3">
-                <Icon className="h-5 w-5" icon={IconProp.Close} color={Red} />
-                <div className="ml-1 font-medium">
-                  {progressInfo.failed.length} {props.pluralLabel} Failed. Here
-                  is more information:
+        <div className="space-y-4">
+          {/* Summary counts */}
+          <div className="flex flex-col space-y-3">
+            {hasSuccesses && (
+              <div className="flex items-center rounded-lg bg-green-50 p-3">
+                <Icon
+                  className="h-5 w-5 flex-shrink-0"
+                  icon={IconProp.CheckCircle}
+                  color={Green}
+                />
+                <div className="ml-2 text-sm font-medium text-green-800">
+                  {progressInfo.successItems.length}{" "}
+                  {progressInfo.successItems.length === 1
+                    ? props.singularLabel
+                    : props.pluralLabel}{" "}
+                  succeeded
                 </div>
               </div>
-              <div>
-                <SimpleLogViewer>
-                  {progressInfo.failed.map(
-                    (failedItem: BulkActionFailed<T>, i: number) => {
-                      return (
-                        <div className="flex mb-2" key={i}>
-                          {actionName}{" "}
-                          {props.itemToString
-                            ? props.itemToString(failedItem.item)
-                            : ""}{" "}
-                          {"Failed: "}
+            )}
+            {hasFailures && (
+              <div className="flex items-center rounded-lg bg-red-50 p-3">
+                <Icon
+                  className="h-5 w-5 flex-shrink-0"
+                  icon={IconProp.Close}
+                  color={Red}
+                />
+                <div className="ml-2 text-sm font-medium text-red-800">
+                  {progressInfo.failed.length}{" "}
+                  {progressInfo.failed.length === 1
+                    ? props.singularLabel
+                    : props.pluralLabel}{" "}
+                  failed
+                </div>
+              </div>
+            )}
+          </div>
+
+          {/* Failure details */}
+          {hasFailures && (
+            <div className="rounded-lg border border-gray-200 overflow-hidden">
+              <div className="max-h-64 overflow-y-auto divide-y divide-gray-200">
+                {progressInfo.failed.map(
+                  (failedItem: BulkActionFailed<T>, i: number) => {
+                    const itemName: string = props.itemToString
+                      ? props.itemToString(failedItem.item)
+                      : "";
+
+                    return (
+                      <div className="px-4 py-3 text-sm" key={i}>
+                        {itemName && (
+                          <div className="font-medium text-gray-900">
+                            {itemName}
+                          </div>
+                        )}
+                        <div className="text-gray-500 mt-0.5">
                           {failedItem.failedMessage}
                         </div>
-                      );
-                    },
-                  )}
-                </SimpleLogViewer>
+                      </div>
+                    );
+                  },
+                )}
               </div>
             </div>
           )}
@@ -217,7 +241,6 @@ const BulkUpdateForm: <T extends GenericObject>(
                           },
                           onBulkActionStart: () => {
                             setShowProgressInfoModal(true);
-                            setActionName(button.title);
                             setProgressInfo({
                               inProgressItems: props.selectedItems,
                               successItems: [],
@@ -231,7 +254,6 @@ const BulkUpdateForm: <T extends GenericObject>(
                           },
                           onBulkActionEnd: () => {
                             setActionInProgress(false);
-                            setActionName("");
                           },
                         };
 

package/UI/Components/Dictionary/Dictionary.tsx

@@ -28,6 +28,8 @@ export interface ComponentProps {
   addButtonSuffix?: string | undefined;
   valueTypes?: Array<ValueType>; // by default it'll be Text
   keys?: Array<string> | undefined;
+  valueSuggestions?: Record<string, Array<string>> | undefined;
+  onKeySelected?: ((key: string) => void) | undefined;
 }
 
 interface Item {
@@ -160,6 +162,11 @@ const DictionaryForm: FunctionComponent<ComponentProps> = (
                     newData[index]!.key = value;
                     setData(newData);
                     onDataChange(newData);
+
+                    // If this key matches one of the known keys, notify parent to fetch values
+                    if (props.onKeySelected && props.keys?.includes(value)) {
+                      props.onKeySelected(value);
+                    }
                   }}
                 />
               </div>
@@ -212,9 +219,14 @@ const DictionaryForm: FunctionComponent<ComponentProps> = (
                   />
                 </div>
                 {item.type === ValueType.Text && (
-                  <Input
+                  <AutocompleteTextInput
                     value={item.value.toString()}
                     placeholder={props.valuePlaceholder}
+                    suggestions={
+                      item.key && props.valueSuggestions?.[item.key]
+                        ? props.valueSuggestions[item.key]
+                        : undefined
+                    }
                     onChange={(value: string) => {
                       const newData: Array<Item> = [...data];
                       newData[index]!.value = value;

package/UI/Components/Filters/FiltersForm.tsx

@@ -128,6 +128,8 @@ const FiltersForm: FiltersFormFunction = <T extends GenericObject>(
                       filterData={props.filterData}
                       onFilterChanged={changeFilterData}
                       jsonKeys={filter.jsonKeys}
+                      jsonValueSuggestions={filter.jsonValueSuggestions}
+                      onJsonKeySelected={filter.onJsonKeySelected}
                     />
                   </div>
                 );

package/UI/Components/Filters/JSONFilter.tsx

@@ -12,6 +12,8 @@ export interface ComponentProps<T extends GenericObject> {
   onFilterChanged?: undefined | ((filterData: FilterData<T>) => void);
   filterData: FilterData<T>;
   jsonKeys?: Array<string> | undefined;
+  jsonValueSuggestions?: Record<string, Array<string>> | undefined;
+  onJsonKeySelected?: ((key: string) => void) | undefined;
 }
 
 type JSONFilterFunction = <T extends GenericObject>(
@@ -28,10 +30,12 @@ const JSONFilter: JSONFilterFunction = <T extends GenericObject>(
     return (
       <DictionaryForm
         keys={props.jsonKeys}
+        valueSuggestions={props.jsonValueSuggestions}
+        onKeySelected={props.onJsonKeySelected}
         addButtonSuffix={filter.title}
         keyPlaceholder={"Key"}
         valuePlaceholder={"Value"}
-        valueTypes={[ValueType.Text, ValueType.Number, ValueType.Boolean]}
+        valueTypes={[ValueType.Text]}
         initialValue={(filterData[filter.key] as Dictionary<string>) || {}}
         onChange={(value: Dictionary<string | number | boolean>) => {
           // if no keys in the dictionary, remove the filter

package/UI/Components/Filters/Types/Filter.ts

@@ -8,5 +8,7 @@ export default interface Filter<T extends GenericObject> {
   key: keyof T;
   type: FieldType;
   jsonKeys?: Array<string> | undefined;
+  jsonValueSuggestions?: Record<string, Array<string>> | undefined;
+  onJsonKeySelected?: ((key: string) => void) | undefined;
   isAdvancedFilter?: boolean | undefined;
 }

package/UI/Components/ModelTable/BaseModelTable.tsx

@@ -1689,12 +1689,16 @@ const BaseModelTable: <TBaseModel extends BaseModel | AnalyticsBaseModel>(
         }}
         matchBulkSelectedItemByField={matchBulkSelectedItemByField || "_id"}
         bulkItemToString={(item: TBaseModel) => {
-          return (
-            (props.singularName || item.singularName || "") +
-              " " +
-              item[matchBulkSelectedItemByField]?.toString() +
-              " " || ""
-          );
+          const label: string = props.singularName || item.singularName || "";
+          const name: string =
+            (item as unknown as Record<string, unknown>)["name"]?.toString() ||
+            "";
+          if (name) {
+            return label ? `${label}: ${name}` : name;
+          }
+          const id: string =
+            item[matchBulkSelectedItemByField]?.toString() || "";
+          return label ? `${label} ${id}` : id;
         }}
         filters={classicTableFilters}
         filterError={tableFilterError}