@oneuptime/common 14.0.2 → 14.0.5

package/Tests/Utils/NetworkDiscovery/NetbiosNameUtil.test.ts

@@ -1,5 +1,6 @@
 import {
   MAX_NETBIOS_NAME_LENGTH,
+  isNetbiosQueryableIPv4Address,
   normalizeNetbiosName,
 } from "../../../Utils/NetworkDiscovery/NetbiosNameUtil";
 import { normalizeReverseDnsName } from "../../../Utils/NetworkDiscovery/ReverseDnsNameUtil";
@@ -347,3 +348,246 @@ describe("normalizeNetbiosName — invariants", () => {
     expect(acceptedCount).toBeGreaterThan(50);
   });
 });
+
+/*
+ * OneUptime issue #3916 — the Review dialog told an unnamed host on a scan
+ * with NetBIOS off that "NetBIOS lookup asks Windows hosts for their own
+ * name" whatever its address. The probe only ever queries private and CGNAT
+ * IPv4 (isNetbiosQueryAddressAllowed, Probe/Utils/Discovery/
+ * NetbiosNameResolver.ts), so on public space that advice led to a rescan
+ * whose only news was "not asked".
+ *
+ * This is the browser-safe copy of the probe's rule that the dialog now asks
+ * first. The expectations are written out by hand from RFC 1918 and RFC 6598,
+ * not computed, so a wrong range in the helper cannot agree with itself here.
+ * The probe's NetbiosEligibilityParity test then holds the helper to the
+ * probe's own answer on the same edges and a sweep.
+ */
+describe("isNetbiosQueryableIPv4Address — the addresses the probe would ask", () => {
+  it("accepts the first, last and an inside address of every range", () => {
+    for (const address of [
+      // 10.0.0.0/8
+      "10.0.0.0",
+      "10.0.0.1",
+      "10.16.42.51",
+      "10.255.255.255",
+      // 172.16.0.0/12
+      "172.16.0.0",
+      "172.20.1.2",
+      "172.31.255.255",
+      // 192.168.0.0/16
+      "192.168.0.0",
+      "192.168.1.1",
+      "192.168.255.255",
+      // 100.64.0.0/10, CGNAT
+      "100.64.0.0",
+      "100.100.100.100",
+      "100.127.255.255",
+    ]) {
+      expect({
+        address: address,
+        queryable: isNetbiosQueryableIPv4Address(address),
+      }).toEqual({ address: address, queryable: true });
+    }
+  });
+
+  it("refuses the address just outside each edge, and the special ranges", () => {
+    for (const address of [
+      "9.255.255.255",
+      "11.0.0.0",
+      "172.15.255.255",
+      "172.32.0.0",
+      "192.167.255.255",
+      "192.169.0.0",
+      "100.63.255.255",
+      "100.128.0.0",
+      // Public, documentation, loopback, link-local, broadcast, multicast.
+      "8.8.8.8",
+      "203.0.113.7",
+      "198.51.100.1",
+      "127.0.0.1",
+      "169.254.169.254",
+      "0.0.0.0",
+      "255.255.255.255",
+      "224.0.0.251",
+    ]) {
+      expect({
+        address: address,
+        queryable: isNetbiosQueryableIPv4Address(address),
+      }).toEqual({ address: address, queryable: false });
+    }
+  });
+
+  it("draws the 172.16/12 edge between 15 and 16, and between 31 and 32", () => {
+    expect(isNetbiosQueryableIPv4Address("172.15.0.1")).toBe(false);
+    expect(isNetbiosQueryableIPv4Address("172.16.0.1")).toBe(true);
+    expect(isNetbiosQueryableIPv4Address("172.31.0.1")).toBe(true);
+    expect(isNetbiosQueryableIPv4Address("172.32.0.1")).toBe(false);
+  });
+
+  it("draws the 100.64/10 edge between 63 and 64, and between 127 and 128", () => {
+    expect(isNetbiosQueryableIPv4Address("100.63.0.1")).toBe(false);
+    expect(isNetbiosQueryableIPv4Address("100.64.0.1")).toBe(true);
+    expect(isNetbiosQueryableIPv4Address("100.127.0.1")).toBe(true);
+    expect(isNetbiosQueryableIPv4Address("100.128.0.1")).toBe(false);
+  });
+
+  it("accepts exactly the second octets each first octet allows", () => {
+    /*
+     * Every second octet under the four first octets that have a range, and
+     * under the neighbours of each. The last two octets never matter, since
+     * no range is narrower than a /16, so each is tried at both ends.
+     */
+    const range: (start: number, count: number) => Array<number> = (
+      start: number,
+      count: number,
+    ): Array<number> => {
+      return Array.from({ length: count }, (_value: unknown, index: number) => {
+        return start + index;
+      });
+    };
+    const expected: Array<[number, Array<number>]> = [
+      [9, []],
+      [10, range(0, 256)],
+      [11, []],
+      [99, []],
+      [100, range(64, 64)],
+      [101, []],
+      [171, []],
+      [172, range(16, 16)],
+      [173, []],
+      [191, []],
+      [192, [168]],
+      [193, []],
+    ];
+
+    for (const [first, secondOctets] of expected) {
+      const accepted: Set<number> = new Set<number>();
+
+      for (let second: number = 0; second <= 255; second++) {
+        for (const tail of ["0.0", "0.1", "255.254", "255.255"]) {
+          if (isNetbiosQueryableIPv4Address(`${first}.${second}.${tail}`)) {
+            accepted.add(second);
+          }
+        }
+      }
+
+      expect({ first: first, accepted: Array.from(accepted) }).toEqual({
+        first: first,
+        accepted: secondOctets,
+      });
+    }
+  });
+
+  it("refuses leading zeros, which the probe's net.isIPv4 refuses", () => {
+    /*
+     * "010" is octal to some parsers and ten to others. The sweep never
+     * reports one, and the probe would refuse it, so the dialog must too.
+     */
+    for (const value of [
+      "010.0.0.1",
+      "10.00.0.1",
+      "10.0.00.1",
+      "10.0.0.01",
+      "10.0.0.00",
+      "0172.16.0.1",
+      "172.016.0.1",
+      "192.168.001.1",
+      "100.064.0.1",
+      "00.0.0.0",
+    ]) {
+      expect({
+        value: value,
+        queryable: isNetbiosQueryableIPv4Address(value),
+      }).toEqual({ value: value, queryable: false });
+    }
+  });
+
+  it("refuses surrounding or inner whitespace, rather than trimming it", () => {
+    for (const value of [
+      " 10.0.0.1",
+      "10.0.0.1 ",
+      "\t10.0.0.1",
+      "10.0.0.1\n",
+      "10.0.0.1\r\n",
+      "10. 0.0.1",
+      "10.0.0.1\u00a0",
+      "\u200b10.0.0.1",
+      "\ufeff10.0.0.1",
+      "10.0.0.1\u0000",
+    ]) {
+      expect({
+        value: value,
+        queryable: isNetbiosQueryableIPv4Address(value),
+      }).toEqual({ value: value, queryable: false });
+    }
+  });
+
+  it("refuses everything else that is not a strict dotted quad", () => {
+    for (const value of [
+      "",
+      ".",
+      "...",
+      "10.0.0",
+      "10.0.0.0.1",
+      "10.0.0.1.",
+      ".10.0.0.1",
+      "10..0.1",
+      "10.0.0.256",
+      "10.0.0.999",
+      "10.0.0.1000",
+      "10.0.0.-1",
+      "+10.0.0.1",
+      "0x0a.0.0.1",
+      "1e1.0.0.1",
+      "10.0.0.1/8",
+      "10.0.0.1:137",
+      "::ffff:10.0.0.1",
+      "::ffff:a00:1",
+      "fd00::1",
+      "fe80::1",
+      "2001:db8::5",
+      "::1",
+      "10.0.0.a",
+      "host.corp.example.com",
+      // Full-width and Arabic-Indic digits: digits, but not ASCII ones.
+      "\uff11\uff10.0.0.1",
+      "\u0661\u0660.0.0.1",
+    ]) {
+      expect({
+        value: value,
+        queryable: isNetbiosQueryableIPv4Address(value),
+      }).toEqual({ value: value, queryable: false });
+    }
+  });
+
+  it("refuses anything that is not a string, even one that stringifies to an address", () => {
+    /*
+     * The dialog reads the address out of jsonb. An array or an object with
+     * a toString would pass a check that coerced first; the probe checks the
+     * type, so this does too.
+     */
+    for (const value of [
+      undefined,
+      null,
+      167772161,
+      Number.NaN,
+      true,
+      ["10.0.0.1"],
+      {
+        toString: (): string => {
+          return "10.0.0.1";
+        },
+      },
+    ]) {
+      expect(isNetbiosQueryableIPv4Address(value)).toBe(false);
+    }
+  });
+
+  it("answers a very long input without throwing", () => {
+    expect(isNetbiosQueryableIPv4Address(`${"1".repeat(100000)}.0.0.1`)).toBe(
+      false,
+    );
+    expect(isNetbiosQueryableIPv4Address("10.".repeat(100000))).toBe(false);
+  });
+});

package/Tests/Utils/Rum/SessionTraceState.test.ts

@@ -0,0 +1,239 @@
+import {
+  ParsedSessionTraceState,
+  SESSION_TRACE_STATE_KEY,
+  buildSessionTraceStateMember,
+  parseSessionTraceState,
+} from "../../../Utils/Rum/SessionTraceState";
+
+const SESSION_ID: string = "0123456789abcdef0123456789abcdef";
+const PARENT_ID: string = "fedcba9876543210";
+
+/*
+ * The W3C / OpenTelemetry validation rules for a tracestate member, copied
+ * from @opentelemetry/core's validators. A member that fails them is
+ * dropped by the backend's propagator before any span sees it.
+ */
+const W3C_KEY_PATTERN: RegExp =
+  /^(?:[a-z][_0-9a-z\-*/]{0,255}|[a-z0-9][_0-9a-z\-*/]{0,240}@[a-z][_0-9a-z\-*/]{0,13})$/;
+const W3C_VALUE_PATTERN: RegExp = /^[ -~]{0,255}[!-~]$/;
+const W3C_VALUE_FORBIDDEN: RegExp = /,|=/;
+
+describe("SessionTraceState", () => {
+  describe("buildSessionTraceStateMember", () => {
+    it("writes the session id under the oneuptime key", () => {
+      expect(buildSessionTraceStateMember(SESSION_ID)).toBe(
+        `oneuptime=sid:${SESSION_ID}`,
+      );
+      expect(SESSION_TRACE_STATE_KEY).toBe("oneuptime");
+    });
+
+    it("adds the synthetic parent id only when one is given", () => {
+      expect(buildSessionTraceStateMember(SESSION_ID, PARENT_ID)).toBe(
+        `oneuptime=sid:${SESSION_ID};p:${PARENT_ID}`,
+      );
+      expect(buildSessionTraceStateMember(SESSION_ID, null)).toBe(
+        `oneuptime=sid:${SESSION_ID}`,
+      );
+      expect(buildSessionTraceStateMember(SESSION_ID, "")).toBe(
+        `oneuptime=sid:${SESSION_ID}`,
+      );
+    });
+
+    it("produces a member every W3C tracestate parser accepts", () => {
+      for (const member of [
+        buildSessionTraceStateMember(SESSION_ID),
+        buildSessionTraceStateMember(SESSION_ID, PARENT_ID),
+      ]) {
+        const [key, value] = member.split("=") as [string, string];
+
+        expect(W3C_KEY_PATTERN.test(key)).toBe(true);
+        expect(W3C_VALUE_PATTERN.test(value)).toBe(true);
+        expect(W3C_VALUE_FORBIDDEN.test(value)).toBe(false);
+        expect(member.length).toBeLessThanOrEqual(512);
+      }
+    });
+  });
+
+  describe("parseSessionTraceState", () => {
+    it("round-trips what the recorder writes", () => {
+      expect(
+        parseSessionTraceState(buildSessionTraceStateMember(SESSION_ID)),
+      ).toEqual({
+        sessionTraceState: {
+          sessionId: SESSION_ID,
+          syntheticParentSpanId: null,
+        },
+        remainingTraceState: "",
+      });
+
+      expect(
+        parseSessionTraceState(
+          buildSessionTraceStateMember(SESSION_ID, PARENT_ID),
+        ),
+      ).toEqual({
+        sessionTraceState: {
+          sessionId: SESSION_ID,
+          syntheticParentSpanId: PARENT_ID,
+        },
+        remainingTraceState: "",
+      });
+    });
+
+    it("finds the member among other vendors' members and strips only ours", () => {
+      const parsed: ParsedSessionTraceState = parseSessionTraceState(
+        `dd=s:1;o:rum, oneuptime=sid:${SESSION_ID} ,congo=t61rcWkgMzE,tenant@vendor=x`,
+      );
+
+      expect(parsed.sessionTraceState?.sessionId).toBe(SESSION_ID);
+      expect(parsed.remainingTraceState).toBe(
+        "dd=s:1;o:rum,congo=t61rcWkgMzE,tenant@vendor=x",
+      );
+    });
+
+    it("tolerates optional whitespace and tabs around members and fields", () => {
+      const parsed: ParsedSessionTraceState = parseSessionTraceState(
+        `\toneuptime = sid:${SESSION_ID} ; p:${PARENT_ID}\t`,
+      );
+
+      expect(parsed.sessionTraceState).toEqual({
+        sessionId: SESSION_ID,
+        syntheticParentSpanId: PARENT_ID,
+      });
+    });
+
+    it("reads fields in any order and ignores unknown ones", () => {
+      expect(
+        parseSessionTraceState(
+          `oneuptime=v:2;p:${PARENT_ID};x:y;sid:${SESSION_ID}`,
+        ).sessionTraceState,
+      ).toEqual({
+        sessionId: SESSION_ID,
+        syntheticParentSpanId: PARENT_ID,
+      });
+    });
+
+    it("lowercases hex ids", () => {
+      expect(
+        parseSessionTraceState(
+          `oneuptime=sid:${SESSION_ID.toUpperCase()};p:${PARENT_ID.toUpperCase()}`,
+        ).sessionTraceState,
+      ).toEqual({
+        sessionId: SESSION_ID,
+        syntheticParentSpanId: PARENT_ID,
+      });
+    });
+
+    it("takes the first oneuptime member and strips every one", () => {
+      const other: string = "ffffffffffffffffffffffffffffffff";
+      const parsed: ParsedSessionTraceState = parseSessionTraceState(
+        `oneuptime=sid:${SESSION_ID},a=b,oneuptime=sid:${other}`,
+      );
+
+      expect(parsed.sessionTraceState?.sessionId).toBe(SESSION_ID);
+      expect(parsed.remainingTraceState).toBe("a=b");
+    });
+
+    it("strips a malformed member of ours but yields no session", () => {
+      for (const member of [
+        "oneuptime=sid:not-hex",
+        "oneuptime=sid:0123",
+        `oneuptime=sid:${SESSION_ID}00`,
+        "oneuptime=sid:00000000000000000000000000000000",
+        "oneuptime=p:fedcba9876543210",
+        "oneuptime=",
+        "oneuptime",
+        `oneuptime=${SESSION_ID}`,
+      ]) {
+        const parsed: ParsedSessionTraceState = parseSessionTraceState(
+          `${member},keep=me`,
+        );
+
+        expect(parsed.sessionTraceState).toBeNull();
+        expect(parsed.remainingTraceState).toBe("keep=me");
+      }
+    });
+
+    it("keeps the session when only the parent id is malformed", () => {
+      for (const parent of ["xyz", "0000000000000000", "fedcba98765432", ""]) {
+        expect(
+          parseSessionTraceState(`oneuptime=sid:${SESSION_ID};p:${parent}`)
+            .sessionTraceState,
+        ).toEqual({ sessionId: SESSION_ID, syntheticParentSpanId: null });
+      }
+    });
+
+    it("does not match keys that only contain the word", () => {
+      const value: string = `acme@oneuptime=sid:${SESSION_ID},oneuptimex=sid:${SESSION_ID}`;
+      const parsed: ParsedSessionTraceState = parseSessionTraceState(value);
+
+      expect(parsed.sessionTraceState).toBeNull();
+      expect(parsed.remainingTraceState).toBe(value);
+    });
+
+    it("returns the value untouched when there is no member of ours", () => {
+      expect(parseSessionTraceState("rojo=00f067aa0ba902b7")).toEqual({
+        sessionTraceState: null,
+        remainingTraceState: "rojo=00f067aa0ba902b7",
+      });
+      expect(parseSessionTraceState("")).toEqual({
+        sessionTraceState: null,
+        remainingTraceState: "",
+      });
+    });
+
+    it("never throws on non-string input", () => {
+      for (const value of [
+        undefined,
+        null,
+        42,
+        true,
+        {},
+        [`oneuptime=sid:${SESSION_ID}`],
+      ]) {
+        expect(parseSessionTraceState(value)).toEqual({
+          sessionTraceState: null,
+          remainingTraceState: "",
+        });
+      }
+    });
+
+    it("reads no session out of oversized or over-long lists but still strips ours", () => {
+      const others: string = "a=b,".repeat(3000);
+      const huge: string = `oneuptime=sid:${SESSION_ID};p:${PARENT_ID},${others}`;
+      const parsedHuge: ParsedSessionTraceState = parseSessionTraceState(huge);
+
+      expect(parsedHuge.sessionTraceState).toBeNull();
+      expect(parsedHuge.remainingTraceState).toBe("a=b,".repeat(2999) + "a=b");
+      expect(parsedHuge.remainingTraceState).not.toContain(SESSION_ID);
+
+      const many: string = `${"k=v,".repeat(80)}oneuptime=sid:${SESSION_ID}`;
+      const parsedMany: ParsedSessionTraceState = parseSessionTraceState(many);
+
+      expect(parsedMany.sessionTraceState).toBeNull();
+      expect(parsedMany.remainingTraceState).toBe("k=v,".repeat(79) + "k=v");
+    });
+
+    it("leaves an oversized list with no member of ours untouched", () => {
+      const huge: string = "a=b,".repeat(3000);
+      expect(parseSessionTraceState(huge)).toEqual({
+        sessionTraceState: null,
+        remainingTraceState: huge,
+      });
+    });
+
+    it("accepts a long but legitimate list that ends with our member", () => {
+      const others: Array<string> = [];
+
+      for (let i: number = 0; i < 20; i++) {
+        others.push(`vendor${i}=${"x".repeat(30)}`);
+      }
+
+      const value: string = `${others.join(",")},oneuptime=sid:${SESSION_ID}`;
+      expect(value.length).toBeGreaterThan(600);
+
+      const parsed: ParsedSessionTraceState = parseSessionTraceState(value);
+      expect(parsed.sessionTraceState?.sessionId).toBe(SESSION_ID);
+      expect(parsed.remainingTraceState).toBe(others.join(","));
+    });
+  });
+});

package/Tests/Utils/ValueFormatter.test.ts

@@ -116,6 +116,30 @@ describe("ValueFormatter", () => {
         }),
       ).toBe("0.25");
     });
+
+    /*
+     * Redis' memory fragmentation ratio is resident over allocated memory:
+     * about 1.0 when healthy, 1.5 and up when fragmented. Read as a [0, 1]
+     * share it rendered 1.62 as "162.00%" on every chart and in every alert
+     * a user built on it.
+     */
+    test("a fragmentation ratio renders as the ratio it is, never x100", () => {
+      expect(
+        ValueFormatter.formatValue(1.62, "1", {
+          metricName: "redis.memory.fragmentation_ratio",
+        }),
+      ).toBe("1.62");
+      expect(
+        ValueFormatter.formatValue(1.62, "1", {
+          metricName: "redis_mem_fragmentation_ratio",
+        }),
+      ).toBe("1.62");
+      expect(
+        ValueFormatter.getCompactUnit("1", {
+          metricName: "redis.memory.fragmentation_ratio",
+        }),
+      ).toBe("");
+    });
   });
 
   describe("formatValue - annotation-only units", () => {
@@ -267,6 +291,32 @@ describe("ValueFormatter", () => {
         false,
       );
     });
+
+    test("a memory fragmentation ratio is not a fraction", () => {
+      // The OTel redis receiver, and redis_exporter's Prometheus name.
+      expect(
+        ValueFormatter.isFractionMetric("redis.memory.fragmentation_ratio"),
+      ).toBe(false);
+      expect(
+        ValueFormatter.isFractionMetric("redis_mem_fragmentation_ratio"),
+      ).toBe(false);
+      expect(
+        ValueFormatter.isFractionMetric(" Redis.Memory.Fragmentation_Ratio "),
+      ).toBe(false);
+    });
+
+    test("the fragmentation exclusion leaves every other ratio a fraction", () => {
+      for (const metricName of [
+        "db.client.connection.usage_ratio",
+        "redis.keyspace.hit_ratio",
+        "cache_hit_ratio",
+        "some_ratio",
+        // Anchored at the end: only the fragmentation ratio itself.
+        "redis.memory.fragmentation_ratio.utilization",
+      ]) {
+        expect(ValueFormatter.isFractionMetric(metricName)).toBe(true);
+      }
+    });
   });
 
   describe("kubeletstats cores gauges render as cores, never as a percent", () => {

package/Tests/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  /*
+   * The project every file in this directory belongs to: exactly
+   * ../tsconfig.tests.json, the program `npm run compile-tests` type-checks.
+   * Its "include" and "exclude" are inherited and resolve against
+   * packages/Common, where they are written.
+   *
+   * It exists because TypeScript picks a file's project by the nearest
+   * tsconfig.json - editors, and ESLint's typed linting (projectService in
+   * eslint.config.js). ../tsconfig.json excludes Tests, so without this file
+   * the lookup walked on up to the repository-root tsconfig.json, which has
+   * no "include": every Common test was linted, and opened in an editor,
+   * inside a program of the whole monorepo.
+   */
+  "extends": "../tsconfig.tests.json"
+}

package/Types/AI/AIResourceContext.ts

@@ -18,6 +18,7 @@ export enum AIResourceType {
   CloudResource = "CloudResource",
   IoTFleet = "IoTFleet",
   NetworkDevice = "NetworkDevice",
+  DatabaseServer = "DatabaseServer",
 }
 
 export enum AIResourceSubresourceKind {
@@ -81,6 +82,7 @@ const RESOURCE_FACET_KEYS: Record<AIResourceType, string> = {
   [AIResourceType.CloudResource]: "cloudResourceId",
   [AIResourceType.IoTFleet]: "iotFleetId",
   [AIResourceType.NetworkDevice]: "networkDeviceId",
+  [AIResourceType.DatabaseServer]: "databaseServerId",
 };
 
 /*
@@ -186,6 +188,11 @@ export const AI_RESOURCE_SUBRESOURCE_KINDS: Readonly<
   [AIResourceType.ServerlessFunction]: [AIResourceSubresourceKind.Instance],
   [AIResourceType.CloudResource]: [AIResourceSubresourceKind.Instance],
   [AIResourceType.NetworkDevice]: [AIResourceSubresourceKind.Interface],
+  /*
+   * A database's tabs (Endpoints, Metrics, Logs ...) are views of the one
+   * database, never a child with its own identity.
+   */
+  [AIResourceType.DatabaseServer]: [],
 };
 
 export function isAIResourceSubresourceKind(

package/Types/Dashboard/DashboardTemplates.ts

@@ -1939,7 +1939,8 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
       width: 6,
       height: 3,
       metricConfig: {
-        metricName: "k8s.deployment.available_replicas",
+        // The k8s_cluster receiver's name — there is no `_replicas` suffix.
+        metricName: "k8s.deployment.available",
         aggregationType: MetricsAggregationType.Min,
       },
     }),

package/Types/DatabaseServer/DatabaseConnectionSpan.ts

@@ -0,0 +1,77 @@
+/*
+ * Connection-management spans: the CLIENT spans a database client library
+ * emits for opening, checking out or negotiating a connection rather than
+ * for running a query. They carry the same `db.system.name` and
+ * `server.address` as the queries, so a count of "calls" that includes them
+ * roughly doubles for a pooled client (node-postgres emits `pg-pool.connect`
+ * and `pg.connect` around each checkout), and 4 real queries plus their
+ * connects reach a 10-call threshold.
+ *
+ * The rule is by span NAME, exact and case-insensitive, because nothing
+ * else tells them apart across instrumentations:
+ *   - a positive rule ("a query carries db.query.text / db.statement /
+ *     db.operation.name / db.query.summary") does not hold: ioredis stamps
+ *     its `connect` span with `db.query.text = 'connect'`, and .NET's
+ *     SqlClient instrumentation leaves the statement off real queries by
+ *     default;
+ *   - the names below are what the instrumentations themselves call these
+ *     spans, and no query span is ever named exactly like one of them (a
+ *     query span is named after its operation and target: `SELECT orders`,
+ *     `pg.query:SELECT orders`, `get`, `redis-GET`, `find orders`).
+ *
+ * Isomorphic: the client-span discovery SQL (DatabaseEndpointDiscovery)
+ * and the database pages' "Queries" counts read the same list, so the
+ * min-calls threshold and the counts people see agree.
+ */
+export const DATABASE_CONNECTION_SPAN_NAMES: ReadonlyArray<string> = [
+  // node-postgres (@opentelemetry/instrumentation-pg): client and pool connects.
+  "pg.connect",
+  "pg-pool.connect",
+  // ioredis (@opentelemetry/instrumentation-ioredis), SQLAlchemy (Python), pgx (otelpgx, Go).
+  "connect",
+  // node-redis v4 / v5 (@opentelemetry/instrumentation-redis).
+  "redis-connect",
+  // go-redis (redisotel): opening a pooled connection.
+  "redis.dial",
+  // database/sql (otelsql, Go): opening and resetting a pooled connection.
+  "sql.connector.connect",
+  "sql.conn.reset_session",
+  // PHP PDO (opentelemetry-auto-pdo): opening the connection.
+  "PDO::__construct",
+  "PDO::connect",
+  /*
+   * node-oracledb (@opentelemetry/instrumentation-oracledb): getting a
+   * connection, creating a pool, the connect-time protocol, data-type and
+   * authentication round trips, logging off and closing.
+   */
+  "oracledb.getConnection",
+  "oracledb.Pool.getConnection",
+  "oracledb.createPool",
+  "oracledb.ProtocolMessage",
+  "oracledb.DataTypeMessage",
+  "oracledb.AuthMessage",
+  "oracledb.FastAuthMessage",
+  "oracledb.LogOffMessage",
+  "oracledb.Connection.close",
+];
+
+const CONNECTION_SPAN_NAME_SET: ReadonlySet<string> = new Set<string>(
+  DATABASE_CONNECTION_SPAN_NAMES.map((name: string): string => {
+    return name.toLowerCase();
+  }),
+);
+
+/**
+ * True when a database CLIENT span is connection management, not a query
+ * (see DATABASE_CONNECTION_SPAN_NAMES). Compared trimmed and
+ * case-insensitively; a missing name is never a connection span.
+ */
+export function isDatabaseConnectionSpanName(
+  name: string | null | undefined,
+): boolean {
+  if (typeof name !== "string") {
+    return false;
+  }
+
+  return CONNECTION_SPAN_NAME_SET.has(name.trim().toLowerCase());
+}