@comprehend/telemetry-node 0.1.0 → 0.1.2

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm test:*)",
+      "Bash(grep:*)"
+    ],
+    "deny": []
+  }
+}

package/.idea/telemetry-node.iml

@@ -3,7 +3,6 @@
   <component name="NewModuleRootManager">
     <content url="file://$MODULE_DIR$">
       <excludeFolder url="file://$MODULE_DIR$/.tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/dist" />
       <excludeFolder url="file://$MODULE_DIR$/temp" />
       <excludeFolder url="file://$MODULE_DIR$/tmp" />
     </content>

package/dist/ComprehendDevSpanProcessor.js

@@ -427,7 +427,8 @@ function extractErrorInfo(span) {
     const message = attrs['exception.message'] ??
         attrs['http.error_message'] ??
         attrs['db.response.status_code'] ??
-        (isError ? attrs['otel.status_description'] : undefined);
+        (isError ? attrs['otel.status_description'] : undefined) ??
+        (isError ? span.status.message : undefined);
     const type = attrs['exception.type'] ??
         attrs['error.type'] ??
         attrs['http.error_name'];

package/dist/sql-analyzer.d.ts

@@ -10,8 +10,8 @@ export interface SQLAnalysisResult {
 /** Performs a rough tokenization of the SQL, extracts the tables involved and the operations on them, and
  * produces two versions of the query:
  * - A normalized version for hashing purposes that does not account for whitespace, comments, and collapses
- *   IN clauses that might cause a cardinality explosion.
- * - A presentable version that only does the IN clause collapsing */
+ *   IN clauses and VALUES clauses that might cause a cardinality explosion.
+ * - A presentable version that only does the IN clause and VALUES clause collapsing */
 export declare function analyzeSQL(sql: string): SQLAnalysisResult;
 export declare function analyzeSQLTokens(tokens: Token[]): {
     tableOperations: {

package/dist/sql-analyzer.js

@@ -11,14 +11,18 @@ const KEYWORDS = new Set([
 /** Performs a rough tokenization of the SQL, extracts the tables involved and the operations on them, and
  * produces two versions of the query:
  * - A normalized version for hashing purposes that does not account for whitespace, comments, and collapses
- *   IN clauses that might cause a cardinality explosion.
- * - A presentable version that only does the IN clause collapsing */
+ *   IN clauses and VALUES clauses that might cause a cardinality explosion.
+ * - A presentable version that only does the IN clause and VALUES clause collapsing */
 function analyzeSQL(sql) {
     let semanticTokens = new Array();
     let presentableTokens = new Array();
     let seekingInParen = false;
     let analyzingIn = false;
     let skippingIn = false;
+    let seekingValuesParen = false;
+    let skippingValues = false;
+    let lookingForCommaOrEnd = false;
+    let valuesDepth = 0;
     for (let token of tokenizeSQL(sql)) {
         switch (token.type) {
             case "whitespace":
@@ -81,9 +85,82 @@ function analyzeSQL(sql) {
                 skippingIn = false;
             }
         }
+        else if (seekingValuesParen) {
+            // We saw VALUES, and now look for an opening (. Skip whitespace/comments, bail if anything else.
+            switch (token.type) {
+                case "comment":
+                case "whitespace":
+                    presentableTokens.push(token);
+                    break;
+                case "punct":
+                    if (token.value === "(") {
+                        // Just add the opening paren, "..." and closing paren - preserve original spacing
+                        presentableTokens.push(token);
+                        presentableTokens.push({ type: "unknown", value: "..." });
+                        presentableTokens.push({ type: "punct", value: ")" });
+                        seekingValuesParen = false;
+                        skippingValues = true;
+                        valuesDepth = 1;
+                    }
+                    else {
+                        // Not what we expected, go back to normal processing
+                        presentableTokens.push(token);
+                        seekingValuesParen = false;
+                    }
+                    break;
+                default:
+                    // Not what we expected, go back to normal processing
+                    presentableTokens.push(token);
+                    seekingValuesParen = false;
+                    break;
+            }
+        }
+        else if (skippingValues) {
+            // Skip everything until we've consumed all VALUES tuples
+            if (token.type === "punct") {
+                if (token.value === "(") {
+                    valuesDepth++;
+                }
+                else if (token.value === ")") {
+                    valuesDepth--;
+                    if (valuesDepth === 0) {
+                        // This closes a tuple, check for comma indicating more tuples
+                        lookingForCommaOrEnd = true;
+                        skippingValues = false;
+                    }
+                }
+            }
+        }
+        else if (lookingForCommaOrEnd) {
+            // After closing a VALUES tuple, look for comma (more tuples) or end of VALUES
+            switch (token.type) {
+                case "comment":
+                case "whitespace":
+                    // Skip whitespace/comments while looking for comma or end
+                    break;
+                case "punct":
+                    if (token.value === ",") {
+                        // More tuples coming, continue skipping
+                        lookingForCommaOrEnd = false;
+                        skippingValues = true;
+                    }
+                    else {
+                        // Not a comma, so VALUES clause is done
+                        presentableTokens.push(token);
+                        lookingForCommaOrEnd = false;
+                    }
+                    break;
+                default:
+                    // VALUES clause is done, resume normal processing
+                    presentableTokens.push(token);
+                    lookingForCommaOrEnd = false;
+                    break;
+            }
+        }
         else {
             presentableTokens.push(token);
             seekingInParen = token.type === "keyword" && token.value.toUpperCase() === "IN";
+            seekingValuesParen = token.type === "keyword" && token.value.toUpperCase() === "VALUES";
         }
     }
     return {
@@ -261,6 +338,45 @@ function analyzeSQLTokens(tokens) {
                 }
             }
         }
+        // Normalize VALUES (...) clauses
+        if (token.type === 'keyword' && token.value === 'VALUES') {
+            if (tokens[i + 1]?.value === '(') {
+                appendToken('VALUES', 'keyword');
+                appendToken('(', 'punct');
+                appendToken('...', 'identifier');
+                appendToken(')', 'punct');
+                // Skip all VALUES tuples including comma-separated ones
+                let depth = 0;
+                let j = i + 1;
+                while (j < tokens.length) {
+                    if (tokens[j].value === '(') {
+                        depth++;
+                    }
+                    else if (tokens[j].value === ')') {
+                        depth--;
+                        if (depth === 0) {
+                            // Check if there's a comma after this closing paren (more tuples)
+                            let k = j + 1;
+                            while (k < tokens.length && (tokens[k].type === 'whitespace' || tokens[k].type === 'comment')) {
+                                k++;
+                            }
+                            if (tokens[k]?.value === ',') {
+                                // More tuples, continue skipping
+                                j = k + 1;
+                                continue;
+                            }
+                            else {
+                                // No more tuples, we're done
+                                break;
+                            }
+                        }
+                    }
+                    j++;
+                }
+                i = j + 1;
+                continue;
+            }
+        }
         appendToken(token.value, token.type);
         i++;
     }

package/dist/sql-analyzer.test.js

@@ -12,7 +12,7 @@ describe('SQL Analyzer - basic SQL operations', () => {
         const sql = `INSERT INTO logs (message, level) VALUES ('hi', 'info')`;
         const result = (0, sql_analyzer_1.analyzeSQL)(sql);
         expect(result.tableOperations).toEqual({ logs: ['INSERT'] });
-        expect(result.presentableQuery).toEqual(sql);
+        expect(result.presentableQuery).toEqual(`INSERT INTO logs (message, level) VALUES (...)`);
     });
     it('detects an INSERT INTO ... SELECT', () => {
         const sql = `INSERT INTO archive SELECT * FROM logs`;
@@ -85,7 +85,9 @@ describe('SQL Analyzer - basic SQL operations', () => {
             users: ['INSERT', 'UPDATE'],
         });
         expect(result.normalizedQuery).toMatch(/replace\s+into\s+users/i);
-        expect(result.presentableQuery).toEqual(sql);
+        expect(result.presentableQuery).toEqual(`
+            REPLACE INTO users (id, name) VALUES (...);
+          `);
     });
     it('detects operation type from MERGE WHEN clause', () => {
         const sql = `
@@ -103,7 +105,15 @@ describe('SQL Analyzer - basic SQL operations', () => {
             incoming: ['SELECT'],
         });
         expect(result.normalizedQuery).toMatch(/merge\s+into\s+inventory/i);
-        expect(result.presentableQuery).toEqual(sql);
+        expect(result.presentableQuery).toEqual(`
+            MERGE INTO inventory AS t
+            USING incoming AS s
+            ON t.sku = s.sku
+            WHEN MATCHED THEN
+              UPDATE SET t.qty = t.qty + s.qty
+            WHEN NOT MATCHED THEN
+              INSERT (sku, qty) VALUES (...);
+          `);
     });
     it('handles double-quoted identifiers', () => {
         const sql = `SELECT * FROM "Users" WHERE "Users"."Id" = 42`;
@@ -361,3 +371,115 @@ describe('SQL Analyzer - basic SQL operations', () => {
         expect(result.presentableQuery).toEqual(sql);
     });
 });
+describe('SQL Analyzer - bulk INSERT VALUES cardinality reduction', () => {
+    it('collapses single VALUES tuple to maintain consistency', () => {
+        const sql = `INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')`;
+        const result = (0, sql_analyzer_1.analyzeSQL)(sql);
+        expect(result.tableOperations).toEqual({ users: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO users (name, email) VALUES (...)`);
+    });
+    it('collapses multiple VALUES tuples to reduce cardinality', () => {
+        const sql = `INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com'), ('Bob', 'bob@example.com'), ('Charlie', 'charlie@example.com')`;
+        const result = (0, sql_analyzer_1.analyzeSQL)(sql);
+        expect(result.tableOperations).toEqual({ users: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO users (name, email) VALUES (...)`);
+    });
+    it('collapses multi-line bulk INSERT VALUES', () => {
+        const sql = `INSERT INTO products (name, price, category_id) VALUES
+            ('Laptop', 999.99, 1),
+            ('Mouse', 29.99, 2),
+            ('Keyboard', 79.99, 2),
+            ('Monitor', 299.99, 3)`;
+        const result = (0, sql_analyzer_1.analyzeSQL)(sql);
+        expect(result.tableOperations).toEqual({ products: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO products (name, price, category_id) VALUES
+            (...)`);
+    });
+    it('handles bulk INSERT with different spacing and formatting', () => {
+        const sql = `INSERT INTO logs(timestamp,level,message)VALUES('2023-01-01','info','start'),('2023-01-02','error','failed'),('2023-01-03','info','end')`;
+        const result = (0, sql_analyzer_1.analyzeSQL)(sql);
+        expect(result.tableOperations).toEqual({ logs: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO logs(timestamp,level,message)VALUES(...)`);
+    });
+    it('collapses REPLACE INTO with multiple VALUES tuples', () => {
+        const sql = `REPLACE INTO cache (key, value, expires) VALUES ('user:1', 'data1', 3600), ('user:2', 'data2', 3600)`;
+        const result = (0, sql_analyzer_1.analyzeSQL)(sql);
+        expect(result.tableOperations).toEqual({ cache: ['INSERT', 'UPDATE'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`REPLACE INTO cache (key, value, expires) VALUES (...)`);
+    });
+    it('handles bulk INSERT with complex nested values', () => {
+        const sql = `INSERT INTO events (data, metadata) VALUES
+            ('{"type":"login"}', '{"source":"web","ip":"192.168.1.1"}'),
+            ('{"type":"logout"}', '{"source":"mobile","ip":"10.0.0.1"}')`;
+        const result = (0, sql_analyzer_1.analyzeSQL)(sql);
+        expect(result.tableOperations).toEqual({ events: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO events (data, metadata) VALUES
+            (...)`);
+    });
+    it('preserves INSERT with subquery (not VALUES)', () => {
+        const sql = `INSERT INTO archive SELECT * FROM logs WHERE created < '2023-01-01'`;
+        const result = (0, sql_analyzer_1.analyzeSQL)(sql);
+        expect(result.tableOperations).toEqual({
+            archive: ['INSERT'],
+            logs: ['SELECT']
+        });
+        expect(result.presentableQuery).toEqual(sql);
+        expect(result.normalizedQuery).not.toContain("VALUES(...)");
+    });
+    it('handles bulk INSERT with quoted identifiers', () => {
+        const sql = `INSERT INTO "UserProfiles" ("firstName", "lastName") VALUES ('John', 'Doe'), ('Jane', 'Smith')`;
+        const result = (0, sql_analyzer_1.analyzeSQL)(sql);
+        expect(result.tableOperations).toEqual({ userprofiles: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO "UserProfiles" ("firstName", "lastName") VALUES (...)`);
+    });
+    it('handles bulk INSERT with mixed value types including NULL', () => {
+        const sql = `INSERT INTO metrics (name, value, tags) VALUES
+            ('cpu_usage', 85.5, NULL),
+            ('memory_usage', 67.2, 'production'),
+            ('disk_usage', NULL, 'staging')`;
+        const result = (0, sql_analyzer_1.analyzeSQL)(sql);
+        expect(result.tableOperations).toEqual({ metrics: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO metrics (name, value, tags) VALUES
+            (...)`);
+    });
+    it('handles very large bulk INSERT (cardinality explosion scenario)', () => {
+        // Generate a bulk insert with many VALUES tuples to simulate real cardinality issues
+        const valueTuples = Array.from({ length: 100 }, (_, i) => `('user${i}', 'user${i}@example.com')`);
+        const sql = `INSERT INTO users (name, email) VALUES ${valueTuples.join(', ')}`;
+        const result = (0, sql_analyzer_1.analyzeSQL)(sql);
+        expect(result.tableOperations).toEqual({ users: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO users (name, email) VALUES (...)`);
+        // Ensure the normalized query is much shorter than the original
+        expect(result.normalizedQuery.length).toBeLessThan(sql.length / 2);
+    });
+    it('handles bulk INSERT with functions and expressions in VALUES', () => {
+        const sql = `INSERT INTO audit_log (event_time, user_id, action) VALUES
+            (NOW(), 1, 'login'),
+            (CURRENT_TIMESTAMP, 2, 'logout'),
+            (DATE('2023-01-01'), 3, 'update')`;
+        const result = (0, sql_analyzer_1.analyzeSQL)(sql);
+        expect(result.tableOperations).toEqual({ audit_log: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO audit_log (event_time, user_id, action) VALUES
+            (...)`);
+    });
+    it('handles bulk INSERT with parentheses in string values', () => {
+        const sql = `INSERT INTO comments (text, author) VALUES
+            ('This is a comment (with parentheses)', 'user1'),
+            ('Another comment (also with parens)', 'user2')`;
+        const result = (0, sql_analyzer_1.analyzeSQL)(sql);
+        expect(result.tableOperations).toEqual({ comments: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO comments (text, author) VALUES
+            (...)`);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comprehend/telemetry-node",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Integration of comprehend.dev with OpenTelemetry in Node.js and similar environemnts.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/ComprehendDevSpanProcessor.ts

@@ -538,7 +538,8 @@ function extractErrorInfo(span: ReadableSpan): {
         (attrs['exception.message'] as string | undefined) ??
         (attrs['http.error_message'] as string | undefined) ??
         (attrs['db.response.status_code'] as string | undefined) ??
-        (isError ? (attrs['otel.status_description'] as string | undefined) : undefined);
+        (isError ? (attrs['otel.status_description'] as string | undefined) : undefined) ??
+        (isError ? (span.status.message as string | undefined) : undefined);
     const type =
         (attrs['exception.type'] as string | undefined) ??
         (attrs['error.type'] as string | undefined) ??

package/src/sql-analyzer.test.ts

@@ -14,7 +14,7 @@ describe('SQL Analyzer - basic SQL operations', () => {
         const result = analyzeSQL(sql);
 
         expect(result.tableOperations).toEqual({ logs: ['INSERT'] });
-        expect(result.presentableQuery).toEqual(sql);
+        expect(result.presentableQuery).toEqual(`INSERT INTO logs (message, level) VALUES (...)`);
     });
 
     it('detects an INSERT INTO ... SELECT', () => {
@@ -104,7 +104,9 @@ describe('SQL Analyzer - basic SQL operations', () => {
         });
 
         expect(result.normalizedQuery).toMatch(/replace\s+into\s+users/i);
-        expect(result.presentableQuery).toEqual(sql);
+        expect(result.presentableQuery).toEqual(`
+            REPLACE INTO users (id, name) VALUES (...);
+          `);
     });
 
     it('detects operation type from MERGE WHEN clause', () => {
@@ -125,7 +127,15 @@ describe('SQL Analyzer - basic SQL operations', () => {
         });
 
         expect(result.normalizedQuery).toMatch(/merge\s+into\s+inventory/i);
-        expect(result.presentableQuery).toEqual(sql);
+        expect(result.presentableQuery).toEqual(`
+            MERGE INTO inventory AS t
+            USING incoming AS s
+            ON t.sku = s.sku
+            WHEN MATCHED THEN
+              UPDATE SET t.qty = t.qty + s.qty
+            WHEN NOT MATCHED THEN
+              INSERT (sku, qty) VALUES (...);
+          `);
     });
 
     it('handles double-quoted identifiers', () => {
@@ -434,3 +444,140 @@ describe('SQL Analyzer - basic SQL operations', () => {
         expect(result.presentableQuery).toEqual(sql);
     });
 });
+
+describe('SQL Analyzer - bulk INSERT VALUES cardinality reduction', () => {
+    it('collapses single VALUES tuple to maintain consistency', () => {
+        const sql = `INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ users: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO users (name, email) VALUES (...)`);
+    });
+
+    it('collapses multiple VALUES tuples to reduce cardinality', () => {
+        const sql = `INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com'), ('Bob', 'bob@example.com'), ('Charlie', 'charlie@example.com')`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ users: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO users (name, email) VALUES (...)`);
+    });
+
+    it('collapses multi-line bulk INSERT VALUES', () => {
+        const sql = `INSERT INTO products (name, price, category_id) VALUES
+            ('Laptop', 999.99, 1),
+            ('Mouse', 29.99, 2),
+            ('Keyboard', 79.99, 2),
+            ('Monitor', 299.99, 3)`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ products: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO products (name, price, category_id) VALUES
+            (...)`);
+    });
+
+    it('handles bulk INSERT with different spacing and formatting', () => {
+        const sql = `INSERT INTO logs(timestamp,level,message)VALUES('2023-01-01','info','start'),('2023-01-02','error','failed'),('2023-01-03','info','end')`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ logs: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO logs(timestamp,level,message)VALUES(...)`);
+    });
+
+    it('collapses REPLACE INTO with multiple VALUES tuples', () => {
+        const sql = `REPLACE INTO cache (key, value, expires) VALUES ('user:1', 'data1', 3600), ('user:2', 'data2', 3600)`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ cache: ['INSERT', 'UPDATE'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`REPLACE INTO cache (key, value, expires) VALUES (...)`);
+    });
+
+    it('handles bulk INSERT with complex nested values', () => {
+        const sql = `INSERT INTO events (data, metadata) VALUES
+            ('{"type":"login"}', '{"source":"web","ip":"192.168.1.1"}'),
+            ('{"type":"logout"}', '{"source":"mobile","ip":"10.0.0.1"}')`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ events: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO events (data, metadata) VALUES
+            (...)`);
+    });
+
+    it('preserves INSERT with subquery (not VALUES)', () => {
+        const sql = `INSERT INTO archive SELECT * FROM logs WHERE created < '2023-01-01'`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({
+            archive: ['INSERT'],
+            logs: ['SELECT']
+        });
+        expect(result.presentableQuery).toEqual(sql);
+        expect(result.normalizedQuery).not.toContain("VALUES(...)");
+    });
+
+    it('handles bulk INSERT with quoted identifiers', () => {
+        const sql = `INSERT INTO "UserProfiles" ("firstName", "lastName") VALUES ('John', 'Doe'), ('Jane', 'Smith')`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ userprofiles: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO "UserProfiles" ("firstName", "lastName") VALUES (...)`);
+    });
+
+    it('handles bulk INSERT with mixed value types including NULL', () => {
+        const sql = `INSERT INTO metrics (name, value, tags) VALUES
+            ('cpu_usage', 85.5, NULL),
+            ('memory_usage', 67.2, 'production'),
+            ('disk_usage', NULL, 'staging')`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ metrics: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO metrics (name, value, tags) VALUES
+            (...)`);
+    });
+
+    it('handles very large bulk INSERT (cardinality explosion scenario)', () => {
+        // Generate a bulk insert with many VALUES tuples to simulate real cardinality issues
+        const valueTuples = Array.from({length: 100}, (_, i) => `('user${i}', 'user${i}@example.com')`);
+        const sql = `INSERT INTO users (name, email) VALUES ${valueTuples.join(', ')}`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ users: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO users (name, email) VALUES (...)`);
+
+        // Ensure the normalized query is much shorter than the original
+        expect(result.normalizedQuery.length).toBeLessThan(sql.length / 2);
+    });
+
+    it('handles bulk INSERT with functions and expressions in VALUES', () => {
+        const sql = `INSERT INTO audit_log (event_time, user_id, action) VALUES
+            (NOW(), 1, 'login'),
+            (CURRENT_TIMESTAMP, 2, 'logout'),
+            (DATE('2023-01-01'), 3, 'update')`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ audit_log: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO audit_log (event_time, user_id, action) VALUES
+            (...)`);
+    });
+
+    it('handles bulk INSERT with parentheses in string values', () => {
+        const sql = `INSERT INTO comments (text, author) VALUES
+            ('This is a comment (with parentheses)', 'user1'),
+            ('Another comment (also with parens)', 'user2')`;
+        const result = analyzeSQL(sql);
+
+        expect(result.tableOperations).toEqual({ comments: ['INSERT'] });
+        expect(result.normalizedQuery).toContain("VALUES(...)");
+        expect(result.presentableQuery).toEqual(`INSERT INTO comments (text, author) VALUES
+            (...)`);
+    });
+});

package/src/sql-analyzer.ts

@@ -16,14 +16,18 @@ export interface SQLAnalysisResult {
 /** Performs a rough tokenization of the SQL, extracts the tables involved and the operations on them, and
  * produces two versions of the query:
  * - A normalized version for hashing purposes that does not account for whitespace, comments, and collapses
- *   IN clauses that might cause a cardinality explosion.
- * - A presentable version that only does the IN clause collapsing */
+ *   IN clauses and VALUES clauses that might cause a cardinality explosion.
+ * - A presentable version that only does the IN clause and VALUES clause collapsing */
 export function analyzeSQL(sql: string): SQLAnalysisResult {
     let semanticTokens = new Array<Token>();
     let presentableTokens = new Array<Token>();
     let seekingInParen = false;
     let analyzingIn = false;
     let skippingIn = false;
+    let seekingValuesParen = false;
+    let skippingValues = false;
+    let lookingForCommaOrEnd = false;
+    let valuesDepth = 0;
     for (let token of tokenizeSQL(sql)) {
         switch (token.type) {
             case "whitespace":
@@ -87,9 +91,79 @@ export function analyzeSQL(sql: string): SQLAnalysisResult {
                 skippingIn = false;
             }
         }
+        else if (seekingValuesParen) {
+            // We saw VALUES, and now look for an opening (. Skip whitespace/comments, bail if anything else.
+            switch (token.type) {
+                case "comment":
+                case "whitespace":
+                    presentableTokens.push(token);
+                    break;
+                case "punct":
+                    if (token.value === "(") {
+                        // Just add the opening paren, "..." and closing paren - preserve original spacing
+                        presentableTokens.push(token);
+                        presentableTokens.push({ type: "unknown", value: "..." });
+                        presentableTokens.push({ type: "punct", value: ")" });
+                        seekingValuesParen = false;
+                        skippingValues = true;
+                        valuesDepth = 1;
+                    } else {
+                        // Not what we expected, go back to normal processing
+                        presentableTokens.push(token);
+                        seekingValuesParen = false;
+                    }
+                    break;
+                default:
+                    // Not what we expected, go back to normal processing
+                    presentableTokens.push(token);
+                    seekingValuesParen = false;
+                    break;
+            }
+        }
+        else if (skippingValues) {
+            // Skip everything until we've consumed all VALUES tuples
+            if (token.type === "punct") {
+                if (token.value === "(") {
+                    valuesDepth++;
+                } else if (token.value === ")") {
+                    valuesDepth--;
+                    if (valuesDepth === 0) {
+                        // This closes a tuple, check for comma indicating more tuples
+                        lookingForCommaOrEnd = true;
+                        skippingValues = false;
+                    }
+                }
+            }
+        }
+        else if (lookingForCommaOrEnd) {
+            // After closing a VALUES tuple, look for comma (more tuples) or end of VALUES
+            switch (token.type) {
+                case "comment":
+                case "whitespace":
+                    // Skip whitespace/comments while looking for comma or end
+                    break;
+                case "punct":
+                    if (token.value === ",") {
+                        // More tuples coming, continue skipping
+                        lookingForCommaOrEnd = false;
+                        skippingValues = true;
+                    } else {
+                        // Not a comma, so VALUES clause is done
+                        presentableTokens.push(token);
+                        lookingForCommaOrEnd = false;
+                    }
+                    break;
+                default:
+                    // VALUES clause is done, resume normal processing
+                    presentableTokens.push(token);
+                    lookingForCommaOrEnd = false;
+                    break;
+            }
+        }
         else {
             presentableTokens.push(token);
             seekingInParen = token.type === "keyword" && token.value.toUpperCase() === "IN";
+            seekingValuesParen = token.type === "keyword" && token.value.toUpperCase() === "VALUES";
         }
     }
     return {
@@ -288,6 +362,46 @@ export function analyzeSQLTokens(tokens: Token[]) {
             }
         }
 
+        // Normalize VALUES (...) clauses
+        if (token.type === 'keyword' && token.value === 'VALUES') {
+            if (tokens[i + 1]?.value === '(') {
+                appendToken('VALUES', 'keyword');
+                appendToken('(', 'punct');
+                appendToken('...', 'identifier');
+                appendToken(')', 'punct');
+
+                // Skip all VALUES tuples including comma-separated ones
+                let depth = 0;
+                let j = i + 1;
+                while (j < tokens.length) {
+                    if (tokens[j].value === '(') {
+                        depth++;
+                    } else if (tokens[j].value === ')') {
+                        depth--;
+                        if (depth === 0) {
+                            // Check if there's a comma after this closing paren (more tuples)
+                            let k = j + 1;
+                            while (k < tokens.length && (tokens[k].type === 'whitespace' || tokens[k].type === 'comment')) {
+                                k++;
+                            }
+                            if (tokens[k]?.value === ',') {
+                                // More tuples, continue skipping
+                                j = k + 1;
+                                continue;
+                            } else {
+                                // No more tuples, we're done
+                                break;
+                            }
+                        }
+                    }
+                    j++;
+                }
+
+                i = j + 1;
+                continue;
+            }
+        }
+
         appendToken(token.value, token.type);
         i++;
     }