@comprehend/telemetry-node 0.1.0

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/telemetry-node.iml" filepath="$PROJECT_DIR$/.idea/telemetry-node.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/telemetry-node.iml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <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>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>

package/dist/ComprehendDevSpanProcessor.d.ts

@@ -0,0 +1,25 @@
+import { Context } from "@opentelemetry/api";
+import { ReadableSpan, Span, SpanProcessor } from "@opentelemetry/sdk-trace-base";
+export declare class ComprehendDevSpanProcessor implements SpanProcessor {
+    private readonly connection;
+    private observedServices;
+    private observedDatabases;
+    private observedHttpServices;
+    private observedInteractions;
+    private observationsSeq;
+    constructor(options: {
+        organization: string;
+        token: string;
+        debug?: boolean | ((message: string) => void);
+    });
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    private discoverService;
+    private processHTTPRoute;
+    private processDatabaseOperation;
+    private processHttpRequest;
+    private getInteractions;
+    private ingestMessage;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/ComprehendDevSpanProcessor.js

@@ -0,0 +1,447 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComprehendDevSpanProcessor = void 0;
+const sha2_1 = require("@noble/hashes/sha2");
+const utils_1 = require("@noble/hashes/utils");
+const sql_analyzer_1 = require("./sql-analyzer");
+const WebSocketConnection_1 = require("./WebSocketConnection");
+const sqlDbSystems = new Set([
+    'mysql', 'postgresql', 'mssql', 'oracle', 'db2', 'sqlite', 'hsqldb', 'h2',
+    'informix', 'cockroachdb', 'redshift', 'tidb', 'trino', 'greenplum'
+]);
+class ComprehendDevSpanProcessor {
+    constructor(options) {
+        this.observedServices = [];
+        this.observedDatabases = [];
+        this.observedHttpServices = [];
+        this.observedInteractions = new Map();
+        this.observationsSeq = 1;
+        this.connection = new WebSocketConnection_1.WebSocketConnection(options.organization, options.token, options.debug === true ? console.log : options.debug === false ? undefined : options.debug);
+    }
+    onStart(span, parentContext) {
+    }
+    onEnd(span) {
+        const currentService = this.discoverService(span);
+        if (!currentService)
+            return;
+        const attrs = span.attributes;
+        if (span.kind === 1) {
+            // Server span, see if it's something to ingest.
+            if (attrs['http.route'] && attrs['http.method']) {
+                this.processHTTPRoute(currentService, attrs['http.route'], attrs['http.method'], span);
+            }
+        }
+        else if (span.kind === 2) {
+            // Client span, see if it's something to ingest.
+            if (attrs['http.url']) {
+                this.processHttpRequest(currentService, attrs['http.url'], span);
+            }
+        }
+        if (attrs['db.system']) {
+            this.processDatabaseOperation(currentService, span);
+        }
+    }
+    discoverService(span) {
+        // Look for an existing matching entry.
+        const resAttrs = span.resource.attributes;
+        const name = resAttrs['service.name'];
+        if (!name)
+            return;
+        const namespace = resAttrs['service.namespace'];
+        const environment = resAttrs['deployment.environment'];
+        const existing = this.observedServices.find(s => s.name === name &&
+            s.namespace === namespace &&
+            s.environment === environment);
+        if (existing)
+            return existing;
+        // New; hash it and add it to the observed services.
+        const idString = `service:${name}:${namespace ?? ''}:${environment ?? ''}`;
+        const hash = hashIdString(idString);
+        const newService = {
+            name, namespace, environment, hash,
+            httpRoutes: []
+        };
+        this.observedServices.push(newService);
+        // Ingest its existence.
+        const message = {
+            event: "new-entity",
+            type: "service",
+            hash,
+            name,
+            ...(namespace ? { namespace } : {}),
+            ...(environment ? { environment } : {})
+        };
+        this.ingestMessage(message);
+    }
+    processHTTPRoute(service, route, method, span) {
+        // Check if this route+method already exists under the service
+        let observedRoute = service.httpRoutes.find(r => r.route === route && r.method === method);
+        if (!observedRoute) {
+            // It's new; hash it and add it to our collection.
+            const idString = `http-route:${service.hash}:${method}:${route}`;
+            const hash = hashIdString(idString);
+            observedRoute = { method, route, hash };
+            service.httpRoutes.push(observedRoute);
+            // Emit observation message
+            const message = {
+                event: "new-entity",
+                type: "http-route",
+                hash,
+                parent: service.hash,
+                method, route
+            };
+            this.ingestMessage(message);
+        }
+        // Extract the request path, making sure we only get that, without any query string.
+        const attrs = span.attributes;
+        let path;
+        if (attrs['http.target']) {
+            try {
+                // This might be just a path like "/search?q=foo"
+                const rawTarget = attrs['http.target'];
+                const fakeUrl = new URL(rawTarget, 'http://placeholder'); // placeholder base
+                path = fakeUrl.pathname;
+            }
+            catch {
+                path = '/';
+            }
+        }
+        else if (attrs['http.url']) {
+            try {
+                const rawUrl = attrs['http.url'];
+                const parsed = new URL(rawUrl);
+                path = parsed.pathname;
+            }
+            catch {
+                path = '/';
+            }
+        }
+        else {
+            path = '/';
+        }
+        // Build and ingest observation.
+        const status = attrs['http.status_code'] ?? 0;
+        const duration = span.duration;
+        const httpVersion = attrs['http.flavor'];
+        const userAgent = attrs['http.user_agent'];
+        const requestBytes = attrs['http.request_content_length'];
+        const responseBytes = attrs['http.response_content_length'];
+        const { message: errorMessage, type: errorType, stack: stack } = extractErrorInfo(span);
+        const observation = {
+            type: 'http-server',
+            subject: observedRoute.hash,
+            timestamp: span.startTime,
+            path,
+            status,
+            duration,
+            ...(httpVersion ? { httpVersion } : {}),
+            ...(userAgent ? { userAgent } : {}),
+            ...(requestBytes !== undefined ? { requestBytes } : {}),
+            ...(responseBytes !== undefined ? { responseBytes } : {}),
+            ...(errorMessage ? { errorMessage } : {}),
+            ...(errorType ? { errorType } : {}),
+            ...(stack ? { stack } : {})
+        };
+        this.ingestMessage({
+            event: "observations",
+            seq: this.observationsSeq++,
+            observations: [observation]
+        });
+    }
+    processDatabaseOperation(currentService, span) {
+        // Parse the connection string.
+        const attrs = span.attributes;
+        const system = attrs['db.system'];
+        const rawConnection = attrs['db.connection_string'];
+        const parsed = rawConnection
+            ? parseDatabaseConnectionStringRaw(rawConnection)
+            : {
+                scrubbed: '',
+                user: undefined,
+                host: (attrs['net.peer.name'] ?? attrs['net.peer.ip']),
+                port: attrs['net.peer.port']?.toString(),
+                name: attrs['db.name'],
+            };
+        // See if we already have an entry for this database.
+        const hash = hashIdString(`database:${system}:${parsed.host ?? ''}:${parsed.port ?? ''}:${parsed.name ?? ''}`);
+        let observedDatabase = this.observedDatabases.find(db => db.hash === hash);
+        // If we see it for the first time, add and ingest it.
+        if (!observedDatabase) {
+            observedDatabase = {
+                system,
+                host: parsed.host,
+                port: parsed.port ? parseInt(parsed.port) : undefined,
+                name: parsed.name,
+                hash
+            };
+            this.observedDatabases.push(observedDatabase);
+            // The existence of the database.
+            const message = {
+                event: "new-entity",
+                type: "database",
+                hash,
+                system,
+                ...(parsed.name ? { name: parsed.name } : {}),
+                ...(parsed.scrubbed ? { connection: parsed.scrubbed } : {}),
+                ...(parsed.host ? { host: parsed.host } : {}),
+                ...(parsed.port ? { port: parseInt(parsed.port) } : {}),
+                ...(parsed.user ? { user: parsed.user } : {})
+            };
+            this.ingestMessage(message);
+        }
+        // The connection to the database should have an interaction.
+        const interactions = this.getInteractions(currentService.hash, observedDatabase.hash);
+        let connectionInteraction = interactions.dbConnections.find(c => c.connection === parsed.scrubbed && c.user === parsed.user);
+        if (!connectionInteraction) {
+            connectionInteraction = {
+                hash: hashIdString(`db-connection:${currentService.hash}:${observedDatabase.hash}:${parsed.scrubbed ?? ''}:${parsed.user ?? ''}`),
+                connection: parsed.scrubbed,
+                user: parsed.user
+            };
+            interactions.dbConnections.push(connectionInteraction);
+            const message = {
+                event: "new-interaction",
+                type: "db-connection",
+                hash: connectionInteraction.hash,
+                from: currentService.hash,
+                to: observedDatabase.hash,
+                ...(connectionInteraction.connection ? { connection: connectionInteraction.connection } : {}),
+                ...(connectionInteraction.user ? { user: connectionInteraction.user } : {})
+            };
+            this.ingestMessage(message);
+        }
+        // The query of the database from the service (only for SQL for now).
+        if (sqlDbSystems.has(system) && attrs['db.statement']) {
+            // The interaction, based upon the normalized query.
+            let queryInfo = (0, sql_analyzer_1.analyzeSQL)(attrs['db.statement']);
+            let queryInteraction = interactions.dbQueries.find(q => q.query === queryInfo.normalizedQuery);
+            if (!queryInteraction) {
+                queryInteraction = {
+                    hash: hashIdString(`db-query:${currentService.hash}:${observedDatabase.hash}:${queryInfo.normalizedQuery}`),
+                    query: queryInfo.normalizedQuery
+                };
+                interactions.dbQueries.push(queryInteraction);
+                const selects = getTablesWithOperation(queryInfo.tableOperations, 'SELECT');
+                const inserts = getTablesWithOperation(queryInfo.tableOperations, 'INSERT');
+                const updates = getTablesWithOperation(queryInfo.tableOperations, 'UPDATE');
+                const deletes = getTablesWithOperation(queryInfo.tableOperations, 'DELETE');
+                const message = {
+                    event: "new-interaction",
+                    type: "db-query",
+                    hash: queryInteraction.hash,
+                    from: currentService.hash,
+                    to: observedDatabase.hash,
+                    query: queryInfo.presentableQuery,
+                    ...(selects ? { selects } : {}),
+                    ...(inserts ? { inserts } : {}),
+                    ...(updates ? { updates } : {}),
+                    ...(deletes ? { deletes } : {}),
+                };
+                this.ingestMessage(message);
+            }
+            // Build and ingest observation.
+            const duration = span.duration;
+            const returnedRows = attrs['db.response.returned_rows']
+                ?? attrs['db.sql.rows'];
+            const { message: errorMessage, type: errorType, stack } = extractErrorInfo(span);
+            const observation = {
+                type: "db-query",
+                subject: queryInteraction.hash,
+                timestamp: span.startTime,
+                duration,
+                ...(errorMessage ? { errorMessage } : {}),
+                ...(errorType ? { errorType } : {}),
+                ...(stack ? { stack } : {}),
+                ...(returnedRows !== undefined ? { returnedRows } : {})
+            };
+            this.ingestMessage({
+                event: "observations",
+                seq: this.observationsSeq++,
+                observations: [observation]
+            });
+        }
+    }
+    processHttpRequest(currentService, url, span) {
+        // Build identity based upon protocol, host, and port.
+        const parsed = new URL(url);
+        const protocol = parsed.protocol.replace(':', ''); // Remove trailing colon
+        const host = parsed.hostname;
+        const port = parsed.port ? parseInt(parsed.port) : (protocol === 'https' ? 443 : 80);
+        const idString = `http-service:${protocol}:${host}:${port}`;
+        const hash = hashIdString(idString);
+        // Ingest it if it's not already observed.
+        let observedHttpService = this.observedHttpServices.find(s => s.protocol === protocol && s.host === host && s.port === port);
+        if (!observedHttpService) {
+            observedHttpService = { protocol, host, port, hash };
+            this.observedHttpServices.push(observedHttpService);
+            // The existence of the service.
+            const message = {
+                event: "new-entity",
+                type: "http-service",
+                hash,
+                protocol,
+                host,
+                port
+            };
+            this.ingestMessage(message);
+        }
+        // Ingest the interaction if first observed.
+        const interactions = this.getInteractions(currentService.hash, observedHttpService.hash);
+        if (!interactions.httpRequest) {
+            const idString = `http-request:${currentService.hash}:${observedHttpService.hash}`;
+            const hash = hashIdString(idString);
+            interactions.httpRequest = { hash };
+            const message = {
+                event: "new-interaction",
+                type: "http-request",
+                hash,
+                from: currentService.hash,
+                to: observedHttpService.hash
+            };
+            this.ingestMessage(message);
+        }
+        // Build and ingest observation.
+        const attrs = span.attributes;
+        const path = parsed.pathname || '/';
+        const method = span.attributes['http.method'];
+        if (!method) // Really should always be there
+            return;
+        const status = attrs['http.status_code'];
+        const duration = span.duration;
+        const httpVersion = span.attributes['http.flavor'];
+        const requestBytes = attrs['http.request_content_length'];
+        const responseBytes = attrs['http.response_content_length'];
+        const { message: errorMessage, type: errorType, stack } = extractErrorInfo(span);
+        const observation = {
+            type: "http-client",
+            subject: interactions.httpRequest.hash,
+            timestamp: span.startTime,
+            path,
+            method,
+            ...(status !== undefined ? { status } : {}),
+            duration,
+            ...(httpVersion !== undefined ? { httpVersion } : {}),
+            ...(requestBytes !== undefined ? { requestBytes } : {}),
+            ...(responseBytes !== undefined ? { responseBytes } : {}),
+            ...(errorMessage ? { errorMessage } : {}),
+            ...(errorType ? { errorType } : {}),
+            ...(stack ? { stack } : {})
+        };
+        this.ingestMessage({
+            event: "observations",
+            seq: this.observationsSeq++,
+            observations: [observation]
+        });
+    }
+    getInteractions(from, to) {
+        let fromMap = this.observedInteractions.get(from);
+        if (!fromMap) {
+            fromMap = new Map();
+            this.observedInteractions.set(from, fromMap);
+        }
+        let interactions = fromMap.get(to);
+        if (!interactions) {
+            interactions = { httpRequest: undefined, dbConnections: [], dbQueries: [] };
+            fromMap.set(to, interactions);
+        }
+        return interactions;
+    }
+    ingestMessage(message) {
+        this.connection.sendMessage(message);
+    }
+    async forceFlush() {
+    }
+    async shutdown() {
+        this.connection.close();
+    }
+}
+exports.ComprehendDevSpanProcessor = ComprehendDevSpanProcessor;
+function hashIdString(idString) {
+    return Array.from((0, sha2_1.sha256)((0, utils_1.utf8ToBytes)(idString)))
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+/** Try to extract data from the database connection string. Many are URL based, fall back on
+ * some kind of comma-seperated style for the rest. */
+function parseDatabaseConnectionStringRaw(conn) {
+    try {
+        // Try URL-style parsing first; scrub the user details if present.
+        const url = new URL(conn);
+        const user = url.username || undefined;
+        const host = url.hostname || undefined;
+        const port = url.port || undefined;
+        const dbName = url.pathname?.replace(/^\//, '') || undefined;
+        url.username = '';
+        url.password = '';
+        return {
+            scrubbed: url.toString(),
+            user,
+            host,
+            port,
+            name: dbName
+        };
+    }
+    catch {
+        // Not a URL-style string; try semi-structured parsing
+        const parts = conn.split(';');
+        const kv = {};
+        for (const part of parts) {
+            const [k, v] = part.split('=');
+            if (k && v)
+                kv[k.trim().toLowerCase()] = v.trim();
+        }
+        const user = kv['user id'] || kv['uid'];
+        const host = kv['server'] || kv['data source'] || kv['address'];
+        const port = kv['port'];
+        const name = kv['database'] || kv['initial catalog'];
+        // Reconstruct a scrubbed connection string without credentials
+        const scrubbed = Object.entries(kv)
+            .filter(([key]) => !['user id', 'uid', 'password', 'pwd'].includes(key))
+            .map(([k, v]) => `${k}=${v}`)
+            .join(';');
+        return {
+            scrubbed,
+            user,
+            host,
+            port,
+            name
+        };
+    }
+}
+/** Try pretty hard to get error info out of a span, if it has any. Handles it being there as an event,
+ * directly on the span with error semantics, and some other more ad-hoc cases. */
+function extractErrorInfo(span) {
+    const attrs = span.attributes;
+    // Try to extract from a structured 'exception' event, as it should have more detail
+    const exceptionEvent = span.events.find(e => e.name === 'exception');
+    if (exceptionEvent?.attributes) {
+        const message = exceptionEvent.attributes['exception.message'];
+        const type = exceptionEvent.attributes['exception.type'];
+        const stack = exceptionEvent.attributes['exception.stacktrace'];
+        if (message || type || stack) {
+            return { message, type, stack };
+        }
+    }
+    // Fallback to attributes directly on the span.
+    const isError = span.status.code === 2;
+    const message = attrs['exception.message'] ??
+        attrs['http.error_message'] ??
+        attrs['db.response.status_code'] ??
+        (isError ? attrs['otel.status_description'] : undefined);
+    const type = attrs['exception.type'] ??
+        attrs['error.type'] ??
+        attrs['http.error_name'];
+    const stack = attrs['exception.stacktrace'];
+    return {
+        message,
+        type,
+        stack
+    };
+}
+function getTablesWithOperation(tableOps, operation) {
+    const op = operation.toUpperCase();
+    const result = Object.entries(tableOps)
+        .filter(([_, ops]) => ops.includes(op))
+        .map(([table]) => table);
+    return result.length > 0 ? result : undefined;
+}

package/dist/WebSocketConnection.d.ts

@@ -0,0 +1,22 @@
+import { ObservationInputMessage } from './wire-protocol';
+export declare class WebSocketConnection {
+    private readonly organization;
+    private readonly token;
+    private readonly logger?;
+    private readonly unacknowledgedObserved;
+    private readonly unacknowledgedObservations;
+    private socket;
+    private reconnectDelay;
+    private shouldReconnect;
+    private authorized;
+    constructor(organization: string, token: string, logger?: (message: string) => void);
+    private log;
+    private connect;
+    private onOpen;
+    private onMessage;
+    private onClose;
+    private onError;
+    private sendRaw;
+    sendMessage(message: ObservationInputMessage): void;
+    close(): void;
+}

package/dist/WebSocketConnection.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketConnection = void 0;
+const ws_1 = __importDefault(require("ws"));
+const INGESTION_ENDPOINT = 'wss://ingestion.comprehend.dev';
+class WebSocketConnection {
+    constructor(organization, token, logger) {
+        this.unacknowledgedObserved = new Map();
+        this.unacknowledgedObservations = new Map();
+        this.socket = null;
+        this.reconnectDelay = 1000;
+        this.shouldReconnect = true;
+        this.authorized = false;
+        this.organization = organization;
+        this.token = token;
+        this.logger = logger;
+        this.connect();
+    }
+    log(message) {
+        if (this.logger) {
+            this.logger(message);
+        }
+    }
+    connect() {
+        const webSocketUrl = `${INGESTION_ENDPOINT}/${this.organization}/observations`;
+        this.log(`Attempting to connect to ${webSocketUrl}...`);
+        this.socket = new ws_1.default(webSocketUrl);
+        this.socket.on('open', () => this.onOpen());
+        this.socket.on('message', (data) => this.onMessage(data));
+        this.socket.on('close', (code, reason) => this.onClose(code, reason.toString()));
+        this.socket.on('error', (err) => this.onError(err));
+    }
+    onOpen() {
+        this.log('WebSocket connected. Sending init/auth message.');
+        const init = {
+            event: 'init',
+            protocolVersion: 1,
+            token: this.token,
+        };
+        this.sendRaw(init);
+    }
+    onMessage(data) {
+        try {
+            const msg = JSON.parse(data.toString());
+            if (msg.type === 'ack-authorized') {
+                this.authorized = true;
+                this.log('Authorization acknowledged by server.');
+                for (const message of this.unacknowledgedObserved.values()) {
+                    this.sendRaw(message);
+                }
+                for (const message of this.unacknowledgedObservations.values()) {
+                    this.sendRaw(message);
+                }
+            }
+            else if (msg.type === 'ack-observed') {
+                this.unacknowledgedObserved.delete(msg.hash);
+            }
+            else if (msg.type === 'ack-observations') {
+                this.unacknowledgedObservations.delete(msg.seq);
+            }
+        }
+        catch (e) {
+            this.log('Error parsing message from server: ' + (e instanceof Error ? e.message : String(e)));
+        }
+    }
+    onClose(code, reason) {
+        this.log(`WebSocket disconnected. Code: ${code}, Reason: ${reason}`);
+        this.authorized = false;
+        if (this.shouldReconnect) {
+            setTimeout(() => this.connect(), this.reconnectDelay);
+        }
+    }
+    onError(error) {
+        this.log(`WebSocket encountered an error: ${error.message}`);
+    }
+    sendRaw(message) {
+        if (this.socket && this.socket.readyState === ws_1.default.OPEN) {
+            this.socket.send(JSON.stringify(message));
+        }
+    }
+    sendMessage(message) {
+        if (message.event === 'new-entity' || message.event === 'new-interaction') {
+            this.unacknowledgedObserved.set(message.hash, message);
+        }
+        else if (message.event === 'observations') {
+            this.unacknowledgedObservations.set(message.seq, message);
+        }
+        if (this.authorized) {
+            this.sendRaw(message);
+        }
+    }
+    close() {
+        this.shouldReconnect = false;
+        if (this.socket) {
+            this.socket.close();
+        }
+    }
+}
+exports.WebSocketConnection = WebSocketConnection;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { ComprehendDevSpanProcessor } from "./ComprehendDevSpanProcessor";

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComprehendDevSpanProcessor = void 0;
+var ComprehendDevSpanProcessor_1 = require("./ComprehendDevSpanProcessor");
+Object.defineProperty(exports, "ComprehendDevSpanProcessor", { enumerable: true, get: function () { return ComprehendDevSpanProcessor_1.ComprehendDevSpanProcessor; } });

package/dist/sql-analyzer.d.ts

@@ -0,0 +1,22 @@
+type Token = {
+    type: 'keyword' | 'identifier' | 'id-quote' | 'string' | 'comment' | 'punct' | 'operator' | 'whitespace' | 'unknown';
+    value: string;
+};
+export interface SQLAnalysisResult {
+    tableOperations: Record<string, string[]>;
+    normalizedQuery: string;
+    presentableQuery: string;
+}
+/** 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 */
+export declare function analyzeSQL(sql: string): SQLAnalysisResult;
+export declare function analyzeSQLTokens(tokens: Token[]): {
+    tableOperations: {
+        [k: string]: string[];
+    };
+    normalizedQuery: string;
+};
+export {};