@oneuptime/common 10.2.4 → 10.2.6

package/Models/DatabaseModels/Service.ts

@@ -725,4 +725,30 @@ export default class Service extends BaseModel {
   })
   public metricDownsamplingRetentionDays?: MetricDownsamplingRetentionDays =
     undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsManager,
+      Permission.ReadService,
+      Permission.ReadAllProjectResources,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Date,
+    canReadOnRelationQuery: true,
+    title: "Last Seen At",
+    description: "When telemetry was last received for this service",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.Date,
+  })
+  public lastSeenAt?: Date = undefined;
 }

package/Server/Infrastructure/Postgres/SchemaMigrations/1778582583897-MigrationName.ts

@@ -0,0 +1,15 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1778582583897 implements MigrationInterface {
+  public name = "MigrationName1778582583897";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Service" ADD "lastSeenAt" TIMESTAMP WITH TIME ZONE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "Service" DROP COLUMN "lastSeenAt"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -316,6 +316,7 @@ import { AddProjectOIDC1778506655291 } from "./1778506655291-AddProjectOIDC";
 import { MigrationName1778514515756 } from "./1778514515756-MigrationName";
 import { MigrationName1778521361934 } from "./1778521361934-MigrationName";
 import { AddStatusPageOIDC1778522070962 } from "./1778522070962-AddStatusPageOIDC";
+import { MigrationName1778582583897 } from "./1778582583897-MigrationName";
 export default [
   InitialMigration,
   MigrationName1717678334852,
@@ -635,4 +636,5 @@ export default [
   MigrationName1778514515756,
   MigrationName1778521361934,
   AddStatusPageOIDC1778522070962,
+  MigrationName1778582583897,
 ];

package/Server/Services/OpenTelemetryIngestService.ts

@@ -64,6 +64,21 @@ export default class OTelIngestService {
       projectId: data.projectId,
     });
 
+    /*
+     * Touch `lastSeenAt` on the service. Throttled per-service inside
+     * ServiceService.updateLastSeen so the steady-state firehose costs
+     * one in-memory cache lookup per batch.
+     */
+    try {
+      await ServiceService.updateLastSeen(result.serviceId);
+    } catch (err) {
+      logger.warn(
+        `telemetryServiceFromName lastSeen update failed for "${data.serviceName}": ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+
     /*
      * Promote `oneuptime.label.<dim>=<val>` resource attributes into
      * project labels and attach them to the discovered service. The

package/Server/Services/ServiceService.ts

@@ -6,6 +6,7 @@ import ArrayUtil from "../../Utils/Array";
 import { BrightColors } from "../../Types/BrandColors";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
+import OneUptimeDate from "../../Types/Date";
 import Model from "../../Models/DatabaseModels/Service";
 import Label from "../../Models/DatabaseModels/Label";
 import Project from "../../Models/DatabaseModels/Project";
@@ -16,6 +17,9 @@ import crypto from "crypto";
 
 const DEFAULT_TELEMETRY_RETENTION_IN_DAYS: number = 15;
 
+const LAST_SEEN_CACHE_NAMESPACE: string = "service-last-seen";
+const LAST_SEEN_THROTTLE_SECONDS: number = 60;
+
 const LABELS_APPLIED_CACHE_NAMESPACE: string = "service-labels-applied";
 const LABELS_APPLIED_CACHE_TTL_SECONDS: number = 60;
 
@@ -80,6 +84,39 @@ export class Service extends DatabaseService<Model> {
     return DEFAULT_TELEMETRY_RETENTION_IN_DAYS;
   }
 
+  /*
+   * Refresh `lastSeenAt` for a service. Throttled per-service so the
+   * steady-state telemetry firehose (every metric/log/trace batch
+   * re-resolves the same serviceId) costs one in-memory cache lookup
+   * per batch instead of a DB write.
+   */
+  @CaptureSpan()
+  public async updateLastSeen(serviceId: ObjectID): Promise<void> {
+    const cacheKey: string = serviceId.toString();
+    const cached: string | null = await GlobalCache.getString(
+      LAST_SEEN_CACHE_NAMESPACE,
+      cacheKey,
+    );
+
+    if (cached) {
+      return;
+    }
+
+    await GlobalCache.setString(LAST_SEEN_CACHE_NAMESPACE, cacheKey, "1", {
+      expiresInSeconds: LAST_SEEN_THROTTLE_SECONDS,
+    });
+
+    await this.updateOneById({
+      id: serviceId,
+      data: {
+        lastSeenAt: OneUptimeDate.getCurrentDate(),
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
   /**
    * Additively attach labels to a telemetry service. Existing labels
    * are never removed — manual labels set via the UI survive ingest.

package/Server/Types/Database/QueryHelper.ts

@@ -138,6 +138,44 @@ export default class QueryHelper {
     );
   }
 
+  /**
+   * Searches the provided entity property names with a single OR-joined ILIKE.
+   *
+   * IMPORTANT: emit unquoted `alias.propertyName` references and let
+   * TypeORM's `replacePropertyNamesForTheWholeQuery` post-processor escape
+   * the table alias and translate property names → DB column names. Pre-
+   * quoting (e.g. `Incident."title"`) bypasses that pass, which leaves an
+   * unquoted `Incident` in the final SQL — Postgres then lowercases it and
+   * fails with `missing FROM-clause entry for table "incident"`.
+   */
+  @CaptureSpan()
+  public static multiSearch(
+    entityPropertyNames: Array<string>,
+    value: string,
+  ): FindWhereProperty<any> {
+    const trimmed: string = value.toLowerCase().trim();
+    const rid: string = Text.generateRandomText(10);
+
+    return Raw(
+      (alias: string) => {
+        const tableAlias: string = alias.includes(".")
+          ? (alias.split(".")[0] as string)
+          : alias;
+
+        const orConditions: string = entityPropertyNames
+          .map((field: string) => {
+            return `(CAST(${tableAlias}.${field} AS TEXT) ILIKE :${rid})`;
+          })
+          .join(" OR ");
+
+        return `(${orConditions})`;
+      },
+      {
+        [rid]: `%${trimmed}%`,
+      },
+    );
+  }
+
   @CaptureSpan()
   public static notContains(name: string): FindWhereProperty<any> {
     name = name.toLowerCase().trim();

package/Server/Types/Database/QueryUtil.ts

@@ -17,6 +17,7 @@ import LessThanOrEqual from "../../../Types/BaseDatabase/LessThanOrEqual";
 import NotEqual from "../../../Types/BaseDatabase/NotEqual";
 import NotNull from "../../../Types/BaseDatabase/NotNull";
 import Search from "../../../Types/BaseDatabase/Search";
+import MultiSearch from "../../../Types/BaseDatabase/MultiSearch";
 import { TableColumnMetadata } from "../../../Types/Database/TableColumn";
 import TableColumnType from "../../../Types/Database/TableColumnType";
 import { JSONObject } from "../../../Types/JSON";
@@ -43,6 +44,82 @@ export default class QueryUtil {
 
     query = query as Query<TBaseModel>;
 
+    /*
+     * Multi-field text search:
+     * A MultiSearch operator on any key fans out into an ILIKE OR across the
+     * listed entity fields. We hang the Raw expression off `_id` so it lands
+     * in the WHERE clause without TypeORM treating the synthetic key as a
+     * real column. Falls through silently if metadata is unavailable or no
+     * fields resolve (e.g. property name typo).
+     */
+    for (const key in query) {
+      const value: any = query[key];
+      if (!(value instanceof MultiSearch)) {
+        continue;
+      }
+
+      delete query[key];
+
+      const ms: MultiSearch = value as MultiSearch;
+      if (!ms.value || ms.fields.length === 0) {
+        continue;
+      }
+
+      /*
+       * Validate the requested fields against entity metadata so we only
+       * emit identifiers TypeORM's post-processor can map back to real
+       * columns (otherwise the alias.field token survives unescaped and
+       * Postgres lowercases the table name → "missing FROM-clause entry").
+       */
+      const validPropertyNames: Array<string> = [];
+      if (PostgresAppInstance.isConnected()) {
+        const dataSource: DataSource | null =
+          PostgresAppInstance.getDataSource();
+        if (dataSource) {
+          let entityMetadata: EntityMetadata | undefined;
+          try {
+            entityMetadata = dataSource.getMetadata(modelType);
+          } catch {
+            entityMetadata = undefined;
+          }
+          if (entityMetadata) {
+            for (const fieldName of ms.fields) {
+              const column: any = entityMetadata.columns.find((c: any) => {
+                return c.propertyName === fieldName;
+              });
+              if (column) {
+                validPropertyNames.push(fieldName);
+              }
+            }
+          }
+        }
+      }
+
+      if (validPropertyNames.length === 0) {
+        continue;
+      }
+
+      const rawFilter: any = QueryHelper.multiSearch(
+        validPropertyNames,
+        ms.value,
+      );
+
+      const existingIdFilter: any = (query as any)._id;
+      if (existingIdFilter instanceof FindOperator) {
+        (query as any)._id = And(existingIdFilter, rawFilter);
+      } else if (
+        existingIdFilter &&
+        typeof existingIdFilter === Typeof.String
+      ) {
+        (query as any)._id = And(
+          QueryHelper.equalTo(existingIdFilter as string),
+          rawFilter,
+        );
+      } else {
+        (query as any)._id = rawFilter;
+      }
+    }
+
     for (const key in query) {
       const tableColumnMetadata: TableColumnMetadata =
         model.getTableColumnMetadata(key);

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -29,6 +29,7 @@ import NotEqual from "../../../Types/BaseDatabase/NotEqual";
 import NotContains from "../../../Types/BaseDatabase/NotContains";
 import NotNull from "../../../Types/BaseDatabase/NotNull";
 import Search from "../../../Types/BaseDatabase/Search";
+import MultiSearch from "../../../Types/BaseDatabase/MultiSearch";
 import StartsWith from "../../../Types/BaseDatabase/StartsWith";
 import EndsWith from "../../../Types/BaseDatabase/EndsWith";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
@@ -356,6 +357,57 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
     let first: boolean = true;
     for (const key in query) {
       const value: any = query[key];
+
+      /*
+       * MultiSearch is a synthetic operator that fans out into an ILIKE OR
+       * across multiple columns — it does not correspond to `key` itself, so
+       * we resolve column metadata per field below.
+       */
+      if (value instanceof MultiSearch) {
+        const ms: MultiSearch = value;
+        if (!ms.value || ms.fields.length === 0) {
+          continue;
+        }
+
+        const resolvedColumns: Array<AnalyticsTableColumn> = [];
+        for (const field of ms.fields) {
+          const col: AnalyticsTableColumn | null =
+            this.model.getTableColumn(field);
+          if (col) {
+            resolvedColumns.push(col);
+          }
+        }
+
+        if (resolvedColumns.length === 0) {
+          continue;
+        }
+
+        if (first) {
+          first = false;
+          whereStatement.append(SQL`AND (`);
+        } else {
+          whereStatement.append(SQL` AND (`);
+        }
+
+        let isFirstCol: boolean = true;
+        for (const col of resolvedColumns) {
+          if (isFirstCol) {
+            isFirstCol = false;
+          } else {
+            whereStatement.append(SQL` OR `);
+          }
+          whereStatement.append(
+            SQL`${col.key} ILIKE ${{
+              value: new Search<string>(ms.value),
+              type: col.type,
+            }}`,
+          );
+        }
+
+        whereStatement.append(SQL`)`);
+        continue;
+      }
+
       const tableColumn: AnalyticsTableColumn | null =
         this.model.getTableColumn(key);
 

package/Types/BaseDatabase/MultiSearch.ts

@@ -0,0 +1,53 @@
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+import QueryOperator from "./QueryOperator";
+
+export default class MultiSearch extends QueryOperator<string> {
+  private _fields: Array<string> = [];
+  private _value: string = "";
+
+  public get fields(): Array<string> {
+    return this._fields;
+  }
+
+  public set fields(v: Array<string>) {
+    this._fields = v;
+  }
+
+  public get value(): string {
+    return this._value;
+  }
+
+  public set value(v: string) {
+    this._value = v;
+  }
+
+  public constructor(data: { fields: Array<string>; value: string }) {
+    super();
+    this.fields = data.fields;
+    this.value = data.value;
+  }
+
+  public override toString(): string {
+    return this.value;
+  }
+
+  public override toJSON(): JSONObject {
+    return {
+      _type: ObjectType.MultiSearch,
+      value: this.value,
+      fields: this.fields,
+    };
+  }
+
+  public static override fromJSON(json: JSONObject): MultiSearch {
+    if (json["_type"] === ObjectType.MultiSearch) {
+      return new MultiSearch({
+        fields: (json["fields"] as Array<string>) || [],
+        value: (json["value"] as string) || "",
+      });
+    }
+
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
+}

package/Types/Dashboard/DashboardComponents/ComponentArgument.ts

@@ -10,6 +10,7 @@ export enum ComponentInputType {
   Decimal = "Decimal",
   MetricsQueryConfig = "MetricsQueryConfig",
   MetricsQueryConfigs = "MetricsQueryConfigs",
+  MetricsFormulaConfigs = "MetricsFormulaConfigs",
   LongText = "Long Text",
   Dropdown = "Dropdown",
   MultiSelectDropdown = "MultiSelectDropdown",

package/Types/Dashboard/DashboardComponents/DashboardChartComponent.ts

@@ -1,3 +1,4 @@
+import MetricFormulaConfigData from "../../Metrics/MetricFormulaConfigData";
 import MetricQueryConfigData from "../../Metrics/MetricQueryConfigData";
 import ObjectID from "../../ObjectID";
 import DashboardComponentType from "../DashboardComponentType";
@@ -10,6 +11,7 @@ export default interface DashboardChartComponent extends BaseComponent {
   arguments: {
     metricQueryConfig?: MetricQueryConfigData | undefined;
     metricQueryConfigs?: Array<MetricQueryConfigData> | undefined;
+    metricFormulaConfigs?: Array<MetricFormulaConfigData> | undefined;
     chartTitle?: string | undefined;
     chartDescription?: string | undefined;
     chartType?: DashboardChartType | undefined;

package/Types/JSON.ts

@@ -17,6 +17,7 @@ import LessThanOrEqual from "./BaseDatabase/LessThanOrEqual";
 import NotEqual from "./BaseDatabase/NotEqual";
 import NotNull from "./BaseDatabase/NotNull";
 import Search from "./BaseDatabase/Search";
+import MultiSearch from "./BaseDatabase/MultiSearch";
 import CallRequest from "./Call/CallRequest";
 import Color from "./Color";
 import { CompareType } from "./Database/CompareBase";
@@ -61,6 +62,7 @@ export enum ObjectType {
   URL = "URL",
   Permission = "Permission",
   Search = "Search",
+  MultiSearch = "MultiSearch",
   GreaterThan = "GreaterThan",
   GreaterThanOrEqual = "GreaterThanOrEqual",
   GreaterThanOrNull = "GreaterThanOrNull",
@@ -123,6 +125,7 @@ export type JSONValue =
   | FilterType
   | Array<FilterType>
   | Search<string>
+  | MultiSearch
   | Domain
   | Array<Domain>
   | Array<Search<string>>

package/Types/SerializableObjectDictionary.ts

@@ -20,6 +20,7 @@ import GreaterThanOrNull from "./BaseDatabase/GreaterThanOrNull";
 import NotEqual from "./BaseDatabase/NotEqual";
 import NotNull from "./BaseDatabase/NotNull";
 import Search from "./BaseDatabase/Search";
+import MultiSearch from "./BaseDatabase/MultiSearch";
 import Color from "./Color";
 import OneUptimeDate from "./Date";
 import Dictionary from "./Dictionary";
@@ -59,6 +60,7 @@ const SerializableObjectDictionary: Dictionary<any> = {
   [ObjectType.URL]: URL,
   [ObjectType.IP]: IP,
   [ObjectType.Search]: Search,
+  [ObjectType.MultiSearch]: MultiSearch,
   [ObjectType.GreaterThan]: GreaterThan,
   [ObjectType.GreaterThanOrEqual]: GreaterThanOrEqual,
   [ObjectType.LessThan]: LessThan,