@oneuptime/common 14.0.10 → 14.0.11

package/Tests/Server/Utils/Telemetry/MessageQueueSpanQueryTwin.ts

@@ -0,0 +1,246 @@
+import {
+  MESSAGE_QUEUE_DISCOVERY_EXCLUDED_SPAN_KIND,
+  MESSAGE_QUEUE_DISCOVERY_SHADOWED_VALUE,
+  MESSAGE_QUEUE_NATS_GENERATED_SUBJECTS,
+  MESSAGE_QUEUE_RABBITMQ_DEFAULT_EXCHANGES,
+  MessagingSpanDiscoveryRow,
+  getMessagingDiscoveryColumn,
+} from "../../../../Server/Utils/Telemetry/MessageQueueDiscovery";
+import {
+  MessagingSystemDescriptor,
+  getMessagingSystemDescriptor,
+} from "../../../../Types/MessageQueue/MessagingSystem";
+import {
+  AZURE_MESSAGING_PROVIDER_NAMESPACES,
+  AZURE_RESOURCE_PROVIDER_ATTRIBUTES,
+  MESSAGING_DESTINATION_ATTRIBUTES,
+  MESSAGING_RESOLVER_INPUT_ATTRIBUTES,
+  MESSAGING_SYSTEM_ATTRIBUTE,
+  MESSAGING_TEMPORARY_FLAG_ATTRIBUTES,
+  MESSAGING_TRIGGER_ATTRIBUTES,
+  RABBITMQ_ROUTING_KEY_ATTRIBUTES,
+} from "../../../../Types/MessageQueue/MessagingTelemetryResolver";
+
+/*
+ * The message queue span query's per-span half — which stored spans its
+ * WHERE reads, and what its folding of values that vary per message
+ * (MessageQueueDiscovery, "Values that vary per message") makes of their
+ * attributes — in TypeScript, with ClickHouse's semantics:
+ *
+ *   - lower() and the case-insensitive searches fold ASCII letters only;
+ *   - match(value, '[!-~]') finds a printable, non-space ASCII character;
+ *   - a key a span lacks reads '' from its attribute map.
+ *
+ * Two suites hold it: the unit tests hold it to the resolver (whatever it
+ * drops names no queue, whatever it folds resolves exactly as before), and
+ * the real-ClickHouse suite holds the query to it (ClickHouse's groups are
+ * exactly the ones it makes, over every stored span).
+ */
+
+// A span as the table keeps it: the kind column, attributeKeys, the map.
+export interface StoredSpan {
+  kind: string | null;
+  attributeKeys: ReadonlyArray<string>;
+  attributes: Readonly<Record<string, string>>;
+}
+
+// ClickHouse's lower() on a String: ASCII letters only.
+export function clickhouseLower(value: string): string {
+  return value.replace(/[A-Z]/g, (letter: string): string => {
+    return letter.toLowerCase();
+  });
+}
+
+// What `attributes['key']` reads: the stored text, '' when absent.
+function storedValue(span: StoredSpan, key: string): string {
+  const value: unknown = Object.prototype.hasOwnProperty.call(
+    span.attributes,
+    key,
+  )
+    ? span.attributes[key]
+    : undefined;
+  return typeof value === "string" ? value : "";
+}
+
+// ClickHouse's match(value, '[!-~]'): a printable, non-space ASCII character.
+const PRINTABLE_ASCII: RegExp = /[!-~]/;
+
+function certainlyHoldsText(value: string): boolean {
+  return PRINTABLE_ASCII.test(value);
+}
+
+// The spellings the catalog maps to NATS, lowercased.
+export function natsSpellings(): Array<string> {
+  const descriptor: MessagingSystemDescriptor | null =
+    getMessagingSystemDescriptor("nats");
+  return (descriptor ? [descriptor.system, ...descriptor.aliases] : ["nats"])
+    .map((spelling: string): string => {
+      return spelling.toLowerCase();
+    })
+    .sort();
+}
+
+/*
+ * The WHERE's reads before its fold: not a stored SERVER span, a trigger key
+ * among attributeKeys, and either a trigger key other than the Azure
+ * provider ones or an Azure provider value naming a messaging provider
+ * (multiSearchAnyCaseInsensitive: an ASCII-case-insensitive substring).
+ */
+export function isReadBySpanQuery(span: StoredSpan): boolean {
+  if ((span.kind ?? "") === MESSAGE_QUEUE_DISCOVERY_EXCLUDED_SPAN_KIND) {
+    return false;
+  }
+  const keys: ReadonlyArray<string> = span.attributeKeys;
+  if (
+    !keys.some((key: string): boolean => {
+      return MESSAGING_TRIGGER_ATTRIBUTES.includes(key);
+    })
+  ) {
+    return false;
+  }
+  const presence: boolean = keys.some((key: string): boolean => {
+    return (
+      MESSAGING_TRIGGER_ATTRIBUTES.includes(key) &&
+      !AZURE_RESOURCE_PROVIDER_ATTRIBUTES.includes(key)
+    );
+  });
+  const provider: boolean = AZURE_RESOURCE_PROVIDER_ATTRIBUTES.some(
+    (key: string): boolean => {
+      const value: string = clickhouseLower(storedValue(span, key));
+      return AZURE_MESSAGING_PROVIDER_NAMESPACES.some(
+        (namespace: string): boolean => {
+          return value.includes(namespace);
+        },
+      );
+    },
+  );
+  return presence || provider;
+}
+
+// Rule 1: a temporary or anonymous flag, or a NATS generated subject.
+function certainlyNamesNoQueue(span: StoredSpan): boolean {
+  for (const key of MESSAGING_TEMPORARY_FLAG_ATTRIBUTES) {
+    if (clickhouseLower(storedValue(span, key)) === "true") {
+      return true;
+    }
+  }
+  if (
+    !natsSpellings().includes(
+      clickhouseLower(storedValue(span, MESSAGING_SYSTEM_ATTRIBUTE)),
+    )
+  ) {
+    return false;
+  }
+  const first: string = clickhouseLower(
+    MESSAGING_DESTINATION_ATTRIBUTES.map((key: string): string => {
+      return storedValue(span, key);
+    }).find((value: string): boolean => {
+      return value !== "";
+    }) || "",
+  );
+  return MESSAGE_QUEUE_NATS_GENERATED_SUBJECTS.some(
+    (subject: string): boolean => {
+      return first === subject || first.startsWith(`${subject}.`);
+    },
+  );
+}
+
+/**
+ * The value of every attribute the span query selects for this span, by
+ * key, after rules 2 and 3 — or null when rule 1 leaves the span out.
+ */
+export function foldStoredSpan(
+  span: StoredSpan,
+): Record<string, string> | null {
+  if (certainlyNamesNoQueue(span)) {
+    return null;
+  }
+
+  const destinations: Array<string> = MESSAGING_DESTINATION_ATTRIBUTES.map(
+    (key: string): string => {
+      return storedValue(span, key);
+    },
+  );
+  const joined: string = destinations.join("");
+  const anyText: boolean = destinations.some(certainlyHoldsText);
+  const routingKeyUnread: boolean =
+    anyText &&
+    !joined.includes(":") &&
+    !joined.includes(",") &&
+    !MESSAGE_QUEUE_RABBITMQ_DEFAULT_EXCHANGES.some(
+      (exchange: string): boolean => {
+        return clickhouseLower(joined).includes(exchange);
+      },
+    );
+
+  const folded: Record<string, string> = {};
+  for (const key of MESSAGING_RESOLVER_INPUT_ATTRIBUTES) {
+    const value: string = storedValue(span, key);
+    const position: number = MESSAGING_DESTINATION_ATTRIBUTES.indexOf(key);
+    if (position > 0) {
+      folded[key] =
+        destinations.slice(0, position).some(certainlyHoldsText) &&
+        certainlyHoldsText(value)
+          ? MESSAGE_QUEUE_DISCOVERY_SHADOWED_VALUE
+          : value;
+    } else if (RABBITMQ_ROUTING_KEY_ATTRIBUTES.includes(key)) {
+      folded[key] = routingKeyUnread ? "" : value;
+    } else {
+      folded[key] = value;
+    }
+  }
+  return folded;
+}
+
+/*
+ * The group a span lands in, as a comparable text: its kind (NULL apart
+ * from '') and every selected column after the fold. Null when the query
+ * does not read the span or rule 1 leaves it out.
+ */
+export function spanQueryGroupKey(span: StoredSpan): string | null {
+  if (!isReadBySpanQuery(span)) {
+    return null;
+  }
+  const folded: Record<string, string> | null = foldStoredSpan(span);
+  if (!folded) {
+    return null;
+  }
+  return JSON.stringify([
+    span.kind,
+    ...MESSAGING_RESOLVER_INPUT_ATTRIBUTES.map((key: string): string => {
+      return folded[key]!;
+    }),
+  ]);
+}
+
+// The same text for a row the span query returned.
+export function spanQueryRowGroupKey(row: MessagingSpanDiscoveryRow): string {
+  return JSON.stringify([
+    row.kind ?? null,
+    ...MESSAGING_RESOLVER_INPUT_ATTRIBUTES.map(
+      (_key: string, index: number): string => {
+        return String(row[getMessagingDiscoveryColumn(index)] ?? "");
+      },
+    ),
+  ]);
+}
+
+// A span query row carrying the folded values, as ClickHouse returns one.
+export function foldedSpanRow(
+  kind: string | null,
+  folded: Record<string, string>,
+  overrides: Partial<MessagingSpanDiscoveryRow> = {},
+): MessagingSpanDiscoveryRow {
+  const row: MessagingSpanDiscoveryRow = {
+    kind: kind,
+    spanCount: "1",
+    errorCount: "0",
+    lastSeenUnixMs: "1790243100123",
+  };
+  MESSAGING_RESOLVER_INPUT_ATTRIBUTES.forEach(
+    (key: string, index: number): void => {
+      row[getMessagingDiscoveryColumn(index)] = folded[key];
+    },
+  );
+  return { ...row, ...overrides };
+}

package/Tests/Server/Utils/Telemetry/TelemetryEntity.test.ts

@@ -1318,6 +1318,29 @@ describe("database.server is membership-only (never resolver-emitted)", () => {
   });
 });
 
+describe("message.queue is membership-only (never resolver-emitted)", () => {
+  test("a broker receiver resource derives no message.queue entity", () => {
+    expect(
+      typesFor({
+        "rabbitmq.queue.name": "orders",
+        "rabbitmq.vhost.name": "/",
+        "rabbitmq.node.name": "rabbit@node-1",
+      }),
+    ).not.toContain(EntityType.MessageQueue);
+  });
+
+  test("an app resource that carries messaging attributes derives none either", () => {
+    expect(
+      typesFor({
+        "service.name": "checkout",
+        "messaging.system": "kafka",
+        "messaging.destination.name": "orders",
+        "server.address": "kafka-1",
+      }),
+    ).not.toContain(EntityType.MessageQueue);
+  });
+});
+
 describe("descriptive attributes & labels (never identity-bearing)", () => {
   test("host: allowlisted descriptive attributes are emitted, key unchanged", () => {
     const bare: ExtractedEntity | undefined = entityOfType(

package/Tests/Types/AI/AIAgentRunLimits.test.ts

@@ -0,0 +1,255 @@
+import AIAgentRunLimitsHelper, {
+  AI_AGENT_RUNAWAY_MAX_LLM_CALLS,
+  AI_AGENT_RUNAWAY_MAX_TOOL_CALLS,
+  AIAgentRunLimits,
+  MAX_AI_INVESTIGATION_TIME_LIMIT_IN_MINUTES,
+  MIN_AI_INVESTIGATION_TIME_LIMIT_IN_MINUTES,
+  TOOL_OUTPUT_PAGE_CHARS,
+} from "../../../Types/AI/AIAgentRunLimits";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The run-limit rules every AI agent loop shares. The product promise these
+ * pin: by default nothing stops an investigation early — no wall clock, and
+ * step counts only a runaway loop could reach — and a project's time limit
+ * is strictly opt-in, so anything that is not a usable positive number
+ * leaves the run unbounded rather than cutting it short.
+ */
+
+const MINUTE_MS: number = 60 * 1000;
+
+describe("AIAgentRunLimitsHelper.getDefault", () => {
+  test("has no time limit", () => {
+    expect(AIAgentRunLimitsHelper.getDefault().maxWallClockMs).toBeUndefined();
+  });
+
+  test("uses the runaway guard for steps", () => {
+    const limits: AIAgentRunLimits = AIAgentRunLimitsHelper.getDefault();
+
+    expect(limits.maxLlmCalls).toBe(AI_AGENT_RUNAWAY_MAX_LLM_CALLS);
+    expect(limits.maxToolCalls).toBe(AI_AGENT_RUNAWAY_MAX_TOOL_CALLS);
+  });
+
+  test("the runaway guard is far above what a real investigation needs", () => {
+    /*
+     * The old per-run budget was 8 LLM calls and 12 tool calls — the limit
+     * that cut real investigations short. The guard must never be that.
+     */
+    expect(AI_AGENT_RUNAWAY_MAX_LLM_CALLS).toBeGreaterThanOrEqual(50);
+    expect(AI_AGENT_RUNAWAY_MAX_TOOL_CALLS).toBeGreaterThanOrEqual(100);
+  });
+
+  test("returns a fresh object each time", () => {
+    const first: AIAgentRunLimits = AIAgentRunLimitsHelper.getDefault();
+    first.maxLlmCalls = 1;
+
+    expect(AIAgentRunLimitsHelper.getDefault().maxLlmCalls).toBe(
+      AI_AGENT_RUNAWAY_MAX_LLM_CALLS,
+    );
+  });
+});
+
+describe("AIAgentRunLimitsHelper.normalizeTimeLimitInMinutes", () => {
+  test.each([
+    [null],
+    [undefined],
+    [0],
+    [-5],
+    [Number.NaN],
+    [Number.POSITIVE_INFINITY],
+    [""],
+    ["abc"],
+    ["0"],
+    ["-3"],
+  ])("%p means no limit", (value: unknown) => {
+    expect(
+      AIAgentRunLimitsHelper.normalizeTimeLimitInMinutes(
+        value as number | string | null | undefined,
+      ),
+    ).toBeNull();
+  });
+
+  test("keeps a whole number of minutes", () => {
+    expect(AIAgentRunLimitsHelper.normalizeTimeLimitInMinutes(15)).toBe(15);
+  });
+
+  test("rounds fractional minutes", () => {
+    expect(AIAgentRunLimitsHelper.normalizeTimeLimitInMinutes(2.4)).toBe(2);
+    expect(AIAgentRunLimitsHelper.normalizeTimeLimitInMinutes(2.6)).toBe(3);
+  });
+
+  test("never rounds a positive value down to nothing", () => {
+    expect(AIAgentRunLimitsHelper.normalizeTimeLimitInMinutes(0.2)).toBe(
+      MIN_AI_INVESTIGATION_TIME_LIMIT_IN_MINUTES,
+    );
+  });
+
+  test("clamps an absurdly long limit", () => {
+    expect(AIAgentRunLimitsHelper.normalizeTimeLimitInMinutes(1_000_000)).toBe(
+      MAX_AI_INVESTIGATION_TIME_LIMIT_IN_MINUTES,
+    );
+  });
+
+  test("accepts a numeric string (form values arrive as strings)", () => {
+    expect(AIAgentRunLimitsHelper.normalizeTimeLimitInMinutes("20")).toBe(20);
+  });
+});
+
+describe("AIAgentRunLimitsHelper.fromTimeLimitInMinutes", () => {
+  test("unset is the default: no time limit", () => {
+    expect(AIAgentRunLimitsHelper.fromTimeLimitInMinutes(null)).toEqual(
+      AIAgentRunLimitsHelper.getDefault(),
+    );
+    expect(AIAgentRunLimitsHelper.fromTimeLimitInMinutes(undefined)).toEqual(
+      AIAgentRunLimitsHelper.getDefault(),
+    );
+  });
+
+  test("a configured limit becomes the wall clock, in milliseconds", () => {
+    expect(
+      AIAgentRunLimitsHelper.fromTimeLimitInMinutes(15).maxWallClockMs,
+    ).toBe(15 * MINUTE_MS);
+  });
+
+  test("a time limit never tightens the step guard", () => {
+    const limits: AIAgentRunLimits =
+      AIAgentRunLimitsHelper.fromTimeLimitInMinutes(5);
+
+    expect(limits.maxLlmCalls).toBe(AI_AGENT_RUNAWAY_MAX_LLM_CALLS);
+    expect(limits.maxToolCalls).toBe(AI_AGENT_RUNAWAY_MAX_TOOL_CALLS);
+  });
+});
+
+describe("AIAgentRunLimitsHelper.getDeadlineAtMs", () => {
+  test("an unlimited run has no deadline", () => {
+    expect(
+      AIAgentRunLimitsHelper.getDeadlineAtMs(
+        AIAgentRunLimitsHelper.getDefault(),
+        1_000,
+      ),
+    ).toBeUndefined();
+  });
+
+  test("a limited run ends its limit after it started", () => {
+    expect(
+      AIAgentRunLimitsHelper.getDeadlineAtMs(
+        { maxWallClockMs: 10 * MINUTE_MS },
+        5_000,
+      ),
+    ).toBe(5_000 + 10 * MINUTE_MS);
+  });
+});
+
+describe("AIAgentRunLimitsHelper.isTimeUp", () => {
+  test("an unlimited run is never out of time", () => {
+    expect(
+      AIAgentRunLimitsHelper.isTimeUp({
+        maxWallClockMs: undefined,
+        startedAtMs: 0,
+        nowMs: 365 * 24 * 60 * MINUTE_MS,
+      }),
+    ).toBe(false);
+  });
+
+  test("a limited run is out of time exactly at its limit", () => {
+    expect(
+      AIAgentRunLimitsHelper.isTimeUp({
+        maxWallClockMs: 1_000,
+        startedAtMs: 0,
+        nowMs: 999,
+      }),
+    ).toBe(false);
+    expect(
+      AIAgentRunLimitsHelper.isTimeUp({
+        maxWallClockMs: 1_000,
+        startedAtMs: 0,
+        nowMs: 1_000,
+      }),
+    ).toBe(true);
+  });
+});
+
+describe("AIAgentRunLimitsHelper.isExhausted", () => {
+  const base: {
+    limits: AIAgentRunLimits;
+    llmCallCount: number;
+    toolCallCount: number;
+    startedAtMs: number;
+    nowMs: number;
+  } = {
+    limits: { maxWallClockMs: undefined, maxLlmCalls: 10, maxToolCalls: 20 },
+    llmCallCount: 0,
+    toolCallCount: 0,
+    startedAtMs: 0,
+    nowMs: 0,
+  };
+
+  test("a fresh run is not exhausted", () => {
+    expect(AIAgentRunLimitsHelper.isExhausted(base)).toBe(false);
+  });
+
+  test("keeps one LLM round for the answer itself", () => {
+    expect(
+      AIAgentRunLimitsHelper.isExhausted({ ...base, llmCallCount: 8 }),
+    ).toBe(false);
+    expect(
+      AIAgentRunLimitsHelper.isExhausted({ ...base, llmCallCount: 9 }),
+    ).toBe(true);
+  });
+
+  test("stops at the tool-call guard", () => {
+    expect(
+      AIAgentRunLimitsHelper.isExhausted({ ...base, toolCallCount: 19 }),
+    ).toBe(false);
+    expect(
+      AIAgentRunLimitsHelper.isExhausted({ ...base, toolCallCount: 20 }),
+    ).toBe(true);
+  });
+
+  test("an unlimited run is never exhausted by time", () => {
+    expect(
+      AIAgentRunLimitsHelper.isExhausted({
+        ...base,
+        nowMs: 30 * 24 * 60 * MINUTE_MS,
+      }),
+    ).toBe(false);
+  });
+
+  test("a limited run is exhausted by time", () => {
+    expect(
+      AIAgentRunLimitsHelper.isExhausted({
+        ...base,
+        limits: { ...base.limits, maxWallClockMs: MINUTE_MS },
+        nowMs: MINUTE_MS,
+      }),
+    ).toBe(true);
+  });
+});
+
+describe("AIAgentRunLimitsHelper.describeTimeLimit", () => {
+  test("says plainly that an unset limit means none", () => {
+    expect(AIAgentRunLimitsHelper.describeTimeLimit(null)).toBe(
+      "No time limit — the investigation runs until it is done.",
+    );
+  });
+
+  test("describes a configured limit, singular and plural", () => {
+    expect(AIAgentRunLimitsHelper.describeTimeLimit(1)).toBe(
+      "Stops investigating after 1 minute and reports what it found.",
+    );
+    expect(AIAgentRunLimitsHelper.describeTimeLimit(15)).toBe(
+      "Stops investigating after 15 minutes and reports what it found.",
+    );
+  });
+});
+
+describe("TOOL_OUTPUT_PAGE_CHARS", () => {
+  test("fits a busy node's kubectl describe in one page", () => {
+    /*
+     * The reported regression: an 8,000-character cap cut `kubectl describe
+     * node` before its Capacity/Allocatable and conditions sections. A busy
+     * node's describe is ~15–25k characters.
+     */
+    expect(TOOL_OUTPUT_PAGE_CHARS).toBeGreaterThanOrEqual(30_000);
+  });
+});