fix(core): escape dots in object keys during attribute flattening (#1510)

Keys containing dots were incorrectly split on those dots during flattening,
turning {"Key 0.002mm": 31.4} into {"Key 0": {"002mm": 31.4}} instead of
keeping the key intact.

Fix: escape dots (and backslashes) in key segments with backslash sequences
during flattenAttributes, and unescape them in unflattenAttributes. The
splitPath helper walks the string character-by-character so escaped delimiters
are never treated as path separators.

Fixes #1510

Author: selenaalpha77-sketch

packages/core/src/v3/utils/flattenAttributes.ts

@@ -3,6 +3,42 @@ import { Attributes } from "@opentelemetry/api";
 export const NULL_SENTINEL = "$@null((";
 export const CIRCULAR_REFERENCE_SENTINEL = "$@circular((";
 
+// Dots in key names are escaped so they are not mistaken for path delimiters.
+// We use the sequence "\." (backslash + dot).  A literal backslash in a key
+// is itself escaped as "\\" so the encoding is unambiguous.
+function escapeKey(key: string): string {
+  return key.replace(/\\/g, "\\\\").replace(/\./g, "\\.");
+}
+
+function unescapeKey(key: string): string {
+  return key.replace(/\\(.)/g, "$1");
+}
+
+/**
+ * Split a flattened path on unescaped "." separators.
+ * Escaped dots ("\\.") are treated as literal dots within a key segment.
+ */
+function splitPath(path: string): string[] {
+  // Walk the string character by character to correctly handle escape sequences.
+  const parts: string[] = [];
+  let current = "";
+  for (let i = 0; i < path.length; i++) {
+    const ch = path[i];
+    if (ch === "\\" && i + 1 < path.length) {
+      // Escape sequence – consume both characters verbatim.
+      current += ch + path[i + 1];
+      i++;
+    } else if (ch === ".") {
+      parts.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  parts.push(current);
+  return parts;
+}
+
 const DEFAULT_MAX_DEPTH = 128;
 
 export function flattenAttributes(
@@ -116,7 +152,7 @@ class AttributeFlattener {
       for (const [key, value] of obj) {
         if (!this.canAddMoreAttributes()) break;
         // Use the key directly if it's a string, otherwise convert it
-        const keyStr = typeof key === "string" ? key : String(key);
+        const keyStr = typeof key === "string" ? escapeKey(key) : String(key);
         this.#processValue(value, `${prefix || "map"}.${keyStr}`, depth);
       }
       return;
@@ -200,7 +236,7 @@ class AttributeFlattener {
         break;
       }
 
-      const newPrefix = `${prefix ? `${prefix}.` : ""}${Array.isArray(obj) ? `[${key}]` : key}`;
+      const newPrefix = `${prefix ? `${prefix}.` : ""}${Array.isArray(obj) ? `[${key}]` : escapeKey(key)}`;
 
       if (Array.isArray(value)) {
         for (let i = 0; i < value.length; i++) {
@@ -278,7 +314,7 @@ export function unflattenAttributes(
       continue;
     }
 
-    const parts = key.split(".").reduce(
+    const parts = splitPath(key).reduce(
       (acc, part) => {
         if (part.startsWith("[") && part.endsWith("]")) {
           // Handle array indices more precisely
@@ -290,7 +326,7 @@ export function unflattenAttributes(
             acc.push(part.slice(1, -1));
           }
         } else {
-          acc.push(part);
+          acc.push(unescapeKey(part));
         }
         return acc;
       },

packages/core/test/flattenAttributes.test.ts

@@ -547,6 +547,52 @@ describe("flattenAttributes", () => {
     // Should complete without stack overflow
     expect(() => flattenAttributes({ arr: deepArray })).not.toThrow();
   });
+
+  it("handles object keys containing dots (issue #1510)", () => {
+    // Keys with dots must not be treated as path separators during flattening.
+    const obj = { "Key 0.002mm": 31.4 };
+    const flattened = flattenAttributes(obj);
+
+    // The dot inside the key name must be escaped; the flat key should contain
+    // the original key name, not split into sub-paths.
+    expect(flattened).toHaveProperty("Key 0\\.002mm", 31.4);
+    expect(flattened).not.toHaveProperty("Key 0");
+
+    // Round-tripping must restore the original structure.
+    expect(unflattenAttributes(flattened)).toEqual(obj);
+  });
+
+  it("handles nested objects where parent and child keys both contain dots", () => {
+    const obj = { "a.b": { "c.d": "value" } };
+    const flattened = flattenAttributes(obj);
+
+    expect(flattened).toHaveProperty("a\\.b.c\\.d", "value");
+    expect(unflattenAttributes(flattened)).toEqual(obj);
+  });
+
+  it("handles object keys containing backslashes", () => {
+    const obj = { "path\\to\\file": "data" };
+    const flattened = flattenAttributes(obj);
+
+    expect(flattened).toHaveProperty("path\\\\to\\\\file", "data");
+    expect(unflattenAttributes(flattened)).toEqual(obj);
+  });
+
+  it("handles object keys containing both dots and backslashes", () => {
+    const obj = { "v1.2\\3": 42 };
+    const flattened = flattenAttributes(obj);
+
+    expect(flattened).toHaveProperty("v1\\.2\\\\3", 42);
+    expect(unflattenAttributes(flattened)).toEqual(obj);
+  });
+
+  it("handles Map objects whose keys contain dots", () => {
+    const myMap = new Map([["key.with.dots", "val"]]);
+    const flattened = flattenAttributes({ myMap });
+
+    expect(flattened).toHaveProperty("myMap.key\\.with\\.dots", "val");
+    expect(flattened).not.toHaveProperty("myMap.key");
+  });
 });
 
 describe("unflattenAttributes", () => {
@@ -667,4 +713,20 @@ describe("unflattenAttributes", () => {
     }
     expect(current).toBeUndefined();
   });
+
+  it("correctly reconstructs keys that contain escaped dots (issue #1510)", () => {
+    // Escaped dot "\." in the flat key must become a literal "." in the
+    // reconstructed object key, not a path separator.
+    const flattened = { "Key 0\\.002mm": 31.4 };
+    const result = unflattenAttributes(flattened);
+
+    expect(result).toEqual({ "Key 0.002mm": 31.4 });
+  });
+
+  it("correctly reconstructs nested paths with escaped dots in key segments", () => {
+    const flattened = { "a\\.b.c\\.d": "value" };
+    const result = unflattenAttributes(flattened);
+
+    expect(result).toEqual({ "a.b": { "c.d": "value" } });
+  });
 });