@oneuptime/common 11.3.8 → 11.3.9

package/Models/AnalyticsModels/ExceptionInstance.ts

@@ -591,6 +591,7 @@ export default class ExceptionInstance extends AnalyticsBaseModel {
       required: true,
       defaultValue: {},
       type: TableColumnType.MapStringString,
+      mapKeysColumn: "attributeKeys",
       accessControl: {
         read: [
           Permission.ProjectOwner,
@@ -614,6 +615,23 @@ export default class ExceptionInstance extends AnalyticsBaseModel {
       },
     });
 
+    const attributeKeysColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "attributeKeys",
+      codec: { codec: "ZSTD", level: 3 },
+      title: "Attribute Keys",
+      description: "Attribute keys extracted from attributes",
+      required: true,
+      defaultValue: [],
+      type: TableColumnType.ArrayText,
+      skipIndex: {
+        name: "idx_attribute_keys",
+        type: SkipIndexType.BloomFilter,
+        params: [0.01],
+        granularity: 1,
+      },
+      accessControl: attributesColumn.accessControl,
+    });
+
     const entityKeysColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
       key: "entityKeys",
       codec: { codec: "ZSTD", level: 3 },
@@ -788,6 +806,7 @@ export default class ExceptionInstance extends AnalyticsBaseModel {
         environmentColumn,
         parsedFramesColumn,
         attributesColumn,
+        attributeKeysColumn,
         entityKeysColumn,
         ...scalarEntityKeyColumns,
         retentionDateColumn,
@@ -918,6 +937,14 @@ export default class ExceptionInstance extends AnalyticsBaseModel {
     this.setColumnValue("attributes", v);
   }
 
+  public get attributeKeys(): Array<string> | undefined {
+    return this.getColumnValue("attributeKeys") as Array<string> | undefined;
+  }
+
+  public set attributeKeys(v: Array<string> | undefined) {
+    this.setColumnValue("attributeKeys", v);
+  }
+
   public get entityKeys(): Array<string> | undefined {
     return this.getColumnValue("entityKeys") as Array<string> | undefined;
   }

package/Models/AnalyticsModels/Log.ts

@@ -253,6 +253,7 @@ export default class Log extends AnalyticsBaseModel {
       required: true,
       defaultValue: {},
       type: TableColumnType.MapStringString,
+      mapKeysColumn: "attributeKeys",
       accessControl: {
         read: [
           Permission.ProjectOwner,

package/Models/AnalyticsModels/Metric.ts

@@ -367,6 +367,7 @@ export default class Metric extends AnalyticsBaseModel {
       required: true,
       type: TableColumnType.MapStringString,
       defaultValue: {},
+      mapKeysColumn: "attributeKeys",
       accessControl: {
         read: [
           Permission.ProjectOwner,

package/Models/AnalyticsModels/Profile.ts

@@ -514,6 +514,7 @@ export default class Profile extends AnalyticsBaseModel {
       required: true,
       defaultValue: {},
       type: TableColumnType.MapStringString,
+      mapKeysColumn: "attributeKeys",
       accessControl: {
         read: [
           Permission.ProjectOwner,

package/Models/AnalyticsModels/Span.ts

@@ -464,6 +464,7 @@ export default class Span extends AnalyticsBaseModel {
       required: true,
       defaultValue: {},
       type: TableColumnType.MapStringString,
+      mapKeysColumn: "attributeKeys",
       accessControl: {
         read: [
           Permission.ProjectOwner,

package/Server/Infrastructure/Queue.ts

@@ -455,6 +455,23 @@ export default class Queue {
     }
   }
 
+  private static normalizeFailedReason(reason: string | undefined): string {
+    if (typeof reason !== "string") {
+      return "No reason provided";
+    }
+
+    const normalized: string = reason.trim().toLowerCase();
+    if (
+      normalized.length === 0 ||
+      normalized === "null" ||
+      normalized === "undefined"
+    ) {
+      return "No reason provided";
+    }
+
+    return reason;
+  }
+
   @CaptureSpan()
   public static async getQueueSize(queueName: QueueName): Promise<number> {
     const queue: BullQueue = this.getQueue(queueName);
@@ -534,7 +551,7 @@ export default class Queue {
         id: job.id || "unknown",
         name: job.name || "unknown",
         data: job.data as JSONObject,
-        failedReason: job.failedReason || "No reason provided",
+        failedReason: Queue.normalizeFailedReason(job.failedReason),
         processedOn: job.processedOn ? new Date(job.processedOn) : null,
         finishedOn: job.finishedOn ? new Date(job.finishedOn) : null,
         attemptsMade: job.attemptsMade || 0,
@@ -641,7 +658,7 @@ export default class Queue {
         opts: (job.opts as unknown as JSONObject) || {},
         returnValue: job.returnvalue ?? null,
         progress: (job.progress as number | Record<string, unknown>) ?? null,
-        failedReason: job.failedReason || "No reason provided",
+        failedReason: Queue.normalizeFailedReason(job.failedReason),
         stackTrace: job.stacktrace || [],
         logs: logs,
         attemptsMade: job.attemptsMade || 0,

package/Server/Infrastructure/QueueWorker.ts

@@ -92,7 +92,10 @@ export default class QueueWorker {
           (err as { name?: string })?.name === "TimeoutException"
             ? "timeout"
             : "failure";
-        throw err;
+        throw QueueWorker.toReportableError(
+          err,
+          `${queueName}/${job.name || "unknown"} (job ${job.id ?? "unknown"})`,
+        );
       } finally {
         const elapsedNs: bigint = process.hrtime.bigint() - startNs;
         const durationMs: number = Number(elapsedNs) / 1e6;
@@ -134,6 +137,69 @@ export default class QueueWorker {
     return worker;
   }
 
+  private static toReportableError(err: unknown, context: string): unknown {
+    const messageIsUseful: (value: unknown) => boolean = (
+      value: unknown,
+    ): boolean => {
+      const message: unknown = (value as { message?: unknown })?.message;
+      if (typeof message !== "string") {
+        return false;
+      }
+
+      const normalized: string = message.trim().toLowerCase();
+      return (
+        normalized.length > 0 &&
+        normalized !== "null" &&
+        normalized !== "undefined"
+      );
+    };
+
+    if (err instanceof Error && messageIsUseful(err)) {
+      return err;
+    }
+
+    const detailParts: Array<string> = [];
+
+    const name: unknown = (err as { name?: unknown })?.name;
+    if (typeof name === "string" && name && name !== "Error") {
+      detailParts.push(name);
+    }
+
+    const rawMessage: unknown = (err as { message?: unknown })?.message;
+    if (typeof rawMessage === "string" && rawMessage.trim()) {
+      detailParts.push(rawMessage.trim());
+    }
+
+    if (detailParts.length === 0) {
+      let serialized: string;
+      try {
+        serialized =
+          typeof err === "object" && err !== null
+            ? JSON.stringify(err)
+            : String(err);
+      } catch {
+        serialized = Object.prototype.toString.call(err);
+      }
+
+      detailParts.push(
+        serialized && serialized !== "{}" ? serialized : String(err),
+      );
+    }
+
+    const reportable: Error = new Error(
+      `${context} failed with a non-descriptive error (original message was empty/null). Detail: ${detailParts.join(
+        ": ",
+      )}`,
+    );
+
+    const originalStack: unknown = (err as { stack?: unknown })?.stack;
+    if (typeof originalStack === "string" && originalStack) {
+      reportable.stack = originalStack;
+    }
+
+    return reportable;
+  }
+
   @CaptureSpan()
   public static async runJobWithTimeout(
     timeoutInMS: number,

package/Server/Services/TelemetryAttributeService.ts

@@ -20,9 +20,8 @@ type TelemetrySource = {
   tableName: string;
   attributesColumn: string;
   /*
-   * Some tables (e.g. ExceptionInstance) don't have a separate
-   * attributeKeys array column — only the attributes map. Leave this
-   * undefined for those; the SQL falls back to mapKeys(attributes).
+   * Older telemetry tables may lack a separate attributeKeys array column.
+   * Leave this undefined for those; the SQL falls back to mapKeys(attributes).
    */
   attributeKeysColumn?: string | undefined;
   timeColumn: string;
@@ -83,7 +82,7 @@ export class TelemetryAttributeService {
           service: ExceptionInstanceService,
           tableName: ExceptionInstanceService.model.tableName,
           attributesColumn: "attributes",
-          // ExceptionInstance has no attributeKeys column.
+          attributeKeysColumn: "attributeKeys",
           timeColumn: "time",
         };
       default:

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -82,6 +82,38 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
     this.database = data.database;
   }
 
+  private appendMapKeyPresenceFilter(input: {
+    whereStatement: Statement;
+    mapColumn: AnalyticsTableColumn;
+    mapKey: string;
+    skip?: boolean;
+  }): void {
+    const mapKeysColumnName: string | undefined = input.mapColumn.mapKeysColumn;
+
+    if (input.skip || !mapKeysColumnName) {
+      return;
+    }
+
+    const mapKeysColumn: AnalyticsTableColumn | null =
+      this.model.getTableColumn(mapKeysColumnName);
+
+    if (!mapKeysColumn || mapKeysColumn.type !== TableColumnType.ArrayText) {
+      return;
+    }
+
+    /*
+     * Keep empty key-array rows eligible so data written before the
+     * denormalized column existed, or by a lagging ingest path, is still
+     * checked by the canonical map['key'] predicate that follows.
+     */
+    input.whereStatement.append(
+      SQL`AND (empty(${mapKeysColumn.key}) OR hasAny(${mapKeysColumn.key}, ${{
+        value: [input.mapKey],
+        type: TableColumnType.ArrayText,
+      }})) `,
+    );
+  }
+
   public toUpdateStatement(updateBy: UpdateBy<TBaseModel>): Statement {
     const setStatement: Statement = this.toSetStatement(updateBy.data);
     const whereStatement: Statement = this.toWhereStatement(updateBy.query);
@@ -708,6 +740,11 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
           }
 
           if (mapEntry instanceof NotNull) {
+            this.appendMapKeyPresenceFilter({
+              whereStatement,
+              mapColumn: tableColumn,
+              mapKey,
+            });
             whereStatement.append(
               SQL`AND mapContains(${key}, ${{
                 value: mapKey,
@@ -789,12 +826,21 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
           }
 
           if (mapEntry instanceof EqualTo) {
+            const equalityValue: string = String(
+              (mapEntry as EqualTo<any>).value ?? "",
+            );
+            this.appendMapKeyPresenceFilter({
+              whereStatement,
+              mapColumn: tableColumn,
+              mapKey,
+              skip: equalityValue === "",
+            });
             whereStatement.append(
               SQL`AND ${key}[${{
                 value: mapKey,
                 type: TableColumnType.Text,
               }}] = ${{
-                value: String((mapEntry as EqualTo<any>).value ?? ""),
+                value: equalityValue,
                 type: TableColumnType.Text,
               }}`,
             );
@@ -809,6 +855,11 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
            * threshold and naturally drops those rows.
            */
           if (mapEntry instanceof GreaterThan) {
+            this.appendMapKeyPresenceFilter({
+              whereStatement,
+              mapColumn: tableColumn,
+              mapKey,
+            });
             whereStatement.append(
               SQL`AND toFloat64OrNull(${key}[${{
                 value: mapKey,
@@ -822,6 +873,11 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
           }
 
           if (mapEntry instanceof GreaterThanOrEqual) {
+            this.appendMapKeyPresenceFilter({
+              whereStatement,
+              mapColumn: tableColumn,
+              mapKey,
+            });
             whereStatement.append(
               SQL`AND toFloat64OrNull(${key}[${{
                 value: mapKey,
@@ -835,6 +891,11 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
           }
 
           if (mapEntry instanceof LessThan) {
+            this.appendMapKeyPresenceFilter({
+              whereStatement,
+              mapColumn: tableColumn,
+              mapKey,
+            });
             whereStatement.append(
               SQL`AND toFloat64OrNull(${key}[${{
                 value: mapKey,
@@ -848,6 +909,11 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
           }
 
           if (mapEntry instanceof LessThanOrEqual) {
+            this.appendMapKeyPresenceFilter({
+              whereStatement,
+              mapColumn: tableColumn,
+              mapKey,
+            });
             whereStatement.append(
               SQL`AND toFloat64OrNull(${key}[${{
                 value: mapKey,
@@ -876,6 +942,12 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
             if (includesValues.length === 0) {
               continue;
             }
+            this.appendMapKeyPresenceFilter({
+              whereStatement,
+              mapColumn: tableColumn,
+              mapKey,
+              skip: includesValues.includes(""),
+            });
             whereStatement.append(
               SQL`AND ${key}[${{
                 value: mapKey,
@@ -919,12 +991,19 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
           }
 
           // Bare string/number/boolean — direct Map subscript.
+          const equalityValue: string = String(mapEntry);
+          this.appendMapKeyPresenceFilter({
+            whereStatement,
+            mapColumn: tableColumn,
+            mapKey,
+            skip: equalityValue === "",
+          });
           whereStatement.append(
             SQL`AND ${key}[${{
               value: mapKey,
               type: TableColumnType.Text,
             }}] = ${{
-              value: String(mapEntry),
+              value: equalityValue,
               type: TableColumnType.Text,
             }}`,
           );

package/Tests/Server/Utils/AnalyticsDatabase/StatementGenerator.test.ts

@@ -395,6 +395,214 @@ describe("StatementGenerator", () => {
         expect(statement.query).toBe("");
         expect(statement.query_params).toStrictEqual({});
       });
+
+      describe("map key-array pruning", () => {
+        class MapModelWithAttributeKeys extends AnalyticsBaseModel {
+          public constructor() {
+            super({
+              tableName: "<map-table-with-attribute-keys>",
+              singularName: "<singular>",
+              pluralName: "<plural>",
+              tableColumns: [
+                new AnalyticsTableColumn({
+                  key: "_id",
+                  title: "<title>",
+                  description: "<description>",
+                  required: true,
+                  type: TableColumnType.ObjectID,
+                }),
+                new AnalyticsTableColumn({
+                  key: "attributes",
+                  title: "<title>",
+                  description: "<description>",
+                  required: true,
+                  defaultValue: {},
+                  type: TableColumnType.MapStringString,
+                  mapKeysColumn: "attributeKeys",
+                }),
+                new AnalyticsTableColumn({
+                  key: "attributeKeys",
+                  title: "<title>",
+                  description: "<description>",
+                  required: true,
+                  defaultValue: [],
+                  type: TableColumnType.ArrayText,
+                }),
+              ],
+              crudApiPath: new Route("route"),
+              primaryKeys: ["_id"],
+              sortKeys: ["_id"],
+              partitionKey: "_id",
+              tableEngine: AnalyticsTableEngine.MergeTree,
+            });
+          }
+        }
+
+        class MapModelWithCustomMapKeys extends AnalyticsBaseModel {
+          public constructor() {
+            super({
+              tableName: "<map-table-with-custom-key-column>",
+              singularName: "<singular>",
+              pluralName: "<plural>",
+              tableColumns: [
+                new AnalyticsTableColumn({
+                  key: "_id",
+                  title: "<title>",
+                  description: "<description>",
+                  required: true,
+                  type: TableColumnType.ObjectID,
+                }),
+                new AnalyticsTableColumn({
+                  key: "tags",
+                  title: "<title>",
+                  description: "<description>",
+                  required: true,
+                  defaultValue: {},
+                  type: TableColumnType.MapStringString,
+                  mapKeysColumn: "tagKeys",
+                }),
+                new AnalyticsTableColumn({
+                  key: "tagKeys",
+                  title: "<title>",
+                  description: "<description>",
+                  required: true,
+                  defaultValue: [],
+                  type: TableColumnType.ArrayText,
+                }),
+              ],
+              crudApiPath: new Route("route"),
+              primaryKeys: ["_id"],
+              sortKeys: ["_id"],
+              partitionKey: "_id",
+              tableEngine: AnalyticsTableEngine.MergeTree,
+            });
+          }
+        }
+
+        let mapGeneratorWithAttributeKeys: StatementGenerator<MapModelWithAttributeKeys>;
+
+        beforeEach(() => {
+          mapGeneratorWithAttributeKeys =
+            new StatementGenerator<MapModelWithAttributeKeys>({
+              modelType: MapModelWithAttributeKeys,
+              database: ClickhouseAppInstance,
+            });
+        });
+
+        test("adds linked key-array bloom-index predicate for positive equality filters", () => {
+          const statement: Statement =
+            mapGeneratorWithAttributeKeys.toWhereStatement({
+              attributes: { requestId: "uuid-123" },
+            } as any);
+
+          expect(statement.query).toBe(
+            "AND (empty({p0:Identifier}) OR hasAny({p1:Identifier}, {p2:Array(String)})) AND {p3:Identifier}[{p4:String}] = {p5:String}",
+          );
+          expect(statement.query_params).toStrictEqual({
+            p0: "attributeKeys",
+            p1: "attributeKeys",
+            p2: ["requestId"],
+            p3: "attributes",
+            p4: "requestId",
+            p5: "uuid-123",
+          });
+        });
+
+        test("does not add linked key-array predicate for empty equality because missing keys also match", () => {
+          const statement: Statement =
+            mapGeneratorWithAttributeKeys.toWhereStatement({
+              attributes: { requestId: "" },
+            } as any);
+
+          expect(statement.query).toBe(
+            "AND {p0:Identifier}[{p1:String}] = {p2:String}",
+          );
+          expect(statement.query_params).toStrictEqual({
+            p0: "attributes",
+            p1: "requestId",
+            p2: "",
+          });
+        });
+
+        test("adds linked key-array bloom-index predicate for positive Includes filters", () => {
+          const statement: Statement =
+            mapGeneratorWithAttributeKeys.toWhereStatement({
+              attributes: {
+                "k8s.cluster.name": new Includes(["prod-east", "prod-west"]),
+              },
+            } as any);
+
+          expect(statement.query).toBe(
+            "AND (empty({p0:Identifier}) OR hasAny({p1:Identifier}, {p2:Array(String)})) AND {p3:Identifier}[{p4:String}] IN {p5:Array(String)}",
+          );
+          expect(statement.query_params).toStrictEqual({
+            p0: "attributeKeys",
+            p1: "attributeKeys",
+            p2: ["k8s.cluster.name"],
+            p3: "attributes",
+            p4: "k8s.cluster.name",
+            p5: ["prod-east", "prod-west"],
+          });
+        });
+
+        test("does not add linked key-array predicate for Includes containing empty string", () => {
+          const statement: Statement =
+            mapGeneratorWithAttributeKeys.toWhereStatement({
+              attributes: {
+                "k8s.cluster.name": new Includes(["", "prod-east"]),
+              },
+            } as any);
+
+          expect(statement.query).toBe(
+            "AND {p0:Identifier}[{p1:String}] IN {p2:Array(String)}",
+          );
+          expect(statement.query_params).toStrictEqual({
+            p0: "attributes",
+            p1: "k8s.cluster.name",
+            p2: ["", "prod-east"],
+          });
+        });
+
+        test("does not add linked key-array predicate for NotEqual because missing keys still match", () => {
+          const statement: Statement =
+            mapGeneratorWithAttributeKeys.toWhereStatement({
+              attributes: { requestId: new NotEqual("uuid-123") },
+            } as any);
+
+          expect(statement.query).toBe(
+            "AND {p0:Identifier}[{p1:String}] != {p2:String}",
+          );
+          expect(statement.query_params).toStrictEqual({
+            p0: "attributes",
+            p1: "requestId",
+            p2: "uuid-123",
+          });
+        });
+
+        test("uses mapKeysColumn metadata instead of hardcoded telemetry column names", () => {
+          const customMapGenerator: StatementGenerator<MapModelWithCustomMapKeys> =
+            new StatementGenerator<MapModelWithCustomMapKeys>({
+              modelType: MapModelWithCustomMapKeys,
+              database: ClickhouseAppInstance,
+            });
+
+          const statement: Statement = customMapGenerator.toWhereStatement({
+            tags: { region: "us-east" },
+          } as any);
+
+          expect(statement.query).toBe(
+            "AND (empty({p0:Identifier}) OR hasAny({p1:Identifier}, {p2:Array(String)})) AND {p3:Identifier}[{p4:String}] = {p5:String}",
+          );
+          expect(statement.query_params).toStrictEqual({
+            p0: "tagKeys",
+            p1: "tagKeys",
+            p2: ["region"],
+            p3: "tags",
+            p4: "region",
+            p5: "us-east",
+          });
+        });
+      });
     });
 
     describe("ArrayText columns", () => {