@comprehend/telemetry-node 0.1.3 → 0.2.0

package/dist/ComprehendDevSpanProcessor.js

@@ -1,22 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComprehendDevSpanProcessor = void 0;
+exports.matchSpanRule = matchSpanRule;
 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 api_1 = require("@opentelemetry/api");
 const sqlDbSystems = new Set([
     'mysql', 'postgresql', 'mssql', 'oracle', 'db2', 'sqlite', 'hsqldb', 'h2',
     'informix', 'cockroachdb', 'redshift', 'tidb', 'trino', 'greenplum'
 ]);
 class ComprehendDevSpanProcessor {
-    constructor(options) {
+    constructor(connection) {
         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);
+        this.processContextSet = false;
+        this.spanObservationSpecs = [];
+        this.connection = connection;
+    }
+    updateCustomMetrics(specs) {
+        this.spanObservationSpecs = specs.filter((s) => s.type === 'span');
     }
     onStart(span, parentContext) {
     }
@@ -25,14 +29,12 @@ class ComprehendDevSpanProcessor {
         if (!currentService)
             return;
         const attrs = span.attributes;
-        if (span.kind === 1) {
-            // Server span, see if it's something to ingest.
+        if (span.kind === 1) { // Server span
             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.
+        else if (span.kind === 2) { // Client span
             if (attrs['http.url']) {
                 this.processHttpRequest(currentService, attrs['http.url'], span);
             }
@@ -40,9 +42,12 @@ class ComprehendDevSpanProcessor {
         if (attrs['db.system']) {
             this.processDatabaseOperation(currentService, span);
         }
+        // Report trace span for every span
+        this.reportTraceSpan(span);
+        // Check custom span observation matching
+        this.checkCustomSpanMatching(span);
     }
     discoverService(span) {
-        // Look for an existing matching entry.
         const resAttrs = span.resource.attributes;
         const name = resAttrs['service.name'];
         if (!name)
@@ -54,7 +59,6 @@ class ComprehendDevSpanProcessor {
             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 = {
@@ -62,7 +66,6 @@ class ComprehendDevSpanProcessor {
             httpRoutes: []
         };
         this.observedServices.push(newService);
-        // Ingest its existence.
         const message = {
             event: "new-entity",
             type: "service",
@@ -72,17 +75,21 @@ class ComprehendDevSpanProcessor {
             ...(environment ? { environment } : {})
         };
         this.ingestMessage(message);
+        // Set process context on first service discovery
+        if (!this.processContextSet) {
+            this.processContextSet = true;
+            const resources = flattenResourceAttributes(resAttrs);
+            this.connection.setProcessContext(hash, resources);
+        }
+        return newService;
     }
     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",
@@ -92,14 +99,13 @@ class ComprehendDevSpanProcessor {
             };
             this.ingestMessage(message);
         }
-        // Extract the request path, making sure we only get that, without any query string.
+        // Extract the request path, making sure we strip 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
+                const fakeUrl = new URL(rawTarget, 'http://placeholder');
                 path = fakeUrl.pathname;
             }
             catch {
@@ -119,7 +125,6 @@ class ComprehendDevSpanProcessor {
         else {
             path = '/';
         }
-        // Build and ingest observation.
         const status = attrs['http.status_code'] ?? 0;
         const duration = span.duration;
         const httpVersion = attrs['http.flavor'];
@@ -127,9 +132,12 @@ class ComprehendDevSpanProcessor {
         const requestBytes = attrs['http.request_content_length'];
         const responseBytes = attrs['http.response_content_length'];
         const { message: errorMessage, type: errorType, stack: stack } = extractErrorInfo(span);
+        const { traceId, spanId } = getSpanContext(span);
         const observation = {
             type: 'http-server',
             subject: observedRoute.hash,
+            spanId,
+            traceId,
             timestamp: span.startTime,
             path,
             status,
@@ -144,12 +152,11 @@ class ComprehendDevSpanProcessor {
         };
         this.ingestMessage({
             event: "observations",
-            seq: this.observationsSeq++,
+            seq: this.connection.nextSeq(),
             observations: [observation]
         });
     }
     processDatabaseOperation(currentService, span) {
-        // Parse the connection string.
         const attrs = span.attributes;
         const system = attrs['db.system'];
         const rawConnection = attrs['db.connection_string'];
@@ -162,10 +169,8 @@ class ComprehendDevSpanProcessor {
                 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,
@@ -175,7 +180,6 @@ class ComprehendDevSpanProcessor {
                 hash
             };
             this.observedDatabases.push(observedDatabase);
-            // The existence of the database.
             const message = {
                 event: "new-entity",
                 type: "database",
@@ -189,7 +193,6 @@ class ComprehendDevSpanProcessor {
             };
             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) {
@@ -210,71 +213,42 @@ class ComprehendDevSpanProcessor {
             };
             this.ingestMessage(message);
         }
-        // The query of the database from the service (only for SQL for now).
+        // For SQL databases, send raw query to server for analysis
         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,
+            const { traceId, spanId } = span.spanContext();
+            const dbQueryMessage = {
+                event: "db-query",
+                seq: this.connection.nextSeq(),
+                query: attrs['db.statement'],
+                from: currentService.hash,
+                to: observedDatabase.hash,
                 timestamp: span.startTime,
                 duration,
+                traceId,
+                spanId,
                 ...(errorMessage ? { errorMessage } : {}),
                 ...(errorType ? { errorType } : {}),
                 ...(stack ? { stack } : {}),
                 ...(returnedRows !== undefined ? { returnedRows } : {})
             };
-            this.ingestMessage({
-                event: "observations",
-                seq: this.observationsSeq++,
-                observations: [observation]
-            });
+            this.ingestMessage(dbQueryMessage);
         }
     }
     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 protocol = parsed.protocol.replace(':', '');
         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",
@@ -285,7 +259,6 @@ class ComprehendDevSpanProcessor {
             };
             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}`;
@@ -300,11 +273,10 @@ class ComprehendDevSpanProcessor {
             };
             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
+        if (!method)
             return;
         const status = attrs['http.status_code'];
         const duration = span.duration;
@@ -312,9 +284,12 @@ class ComprehendDevSpanProcessor {
         const requestBytes = attrs['http.request_content_length'];
         const responseBytes = attrs['http.response_content_length'];
         const { message: errorMessage, type: errorType, stack } = extractErrorInfo(span);
+        const { traceId, spanId } = getSpanContext(span);
         const observation = {
             type: "http-client",
             subject: interactions.httpRequest.hash,
+            spanId,
+            traceId,
             timestamp: span.startTime,
             path,
             method,
@@ -329,10 +304,57 @@ class ComprehendDevSpanProcessor {
         };
         this.ingestMessage({
             event: "observations",
-            seq: this.observationsSeq++,
+            seq: this.connection.nextSeq(),
             observations: [observation]
         });
     }
+    reportTraceSpan(span) {
+        const { traceId, spanId } = getSpanContext(span);
+        const parent = getParentSpanId(span);
+        const traceSpanMessage = {
+            event: "tracespans",
+            seq: this.connection.nextSeq(),
+            data: [{
+                    trace: traceId,
+                    span: spanId,
+                    parent,
+                    name: span.name,
+                    timestamp: span.startTime,
+                }]
+        };
+        this.ingestMessage(traceSpanMessage);
+    }
+    checkCustomSpanMatching(span) {
+        for (const spec of this.spanObservationSpecs) {
+            if (matchSpanRule(span, spec.rule)) {
+                const { traceId, spanId } = getSpanContext(span);
+                const { message: errorMessage, type: errorType, stack } = extractErrorInfo(span);
+                const collectedAttrs = {};
+                for (const [key, value] of Object.entries(span.attributes)) {
+                    if (value !== undefined) {
+                        collectedAttrs[key] = value;
+                    }
+                }
+                const observation = {
+                    type: "custom",
+                    subject: spec.subject,
+                    id: spec.subject,
+                    spanId,
+                    traceId,
+                    timestamp: span.startTime,
+                    attributes: collectedAttrs,
+                    ...(errorMessage ? { errorMessage } : {}),
+                    ...(errorType ? { errorType } : {}),
+                    ...(stack ? { stack } : {}),
+                };
+                this.ingestMessage({
+                    event: "observations",
+                    seq: this.connection.nextSeq(),
+                    observations: [observation]
+                });
+            }
+        }
+    }
     getInteractions(from, to) {
         let fromMap = this.observedInteractions.get(from);
         if (!fromMap) {
@@ -341,7 +363,7 @@ class ComprehendDevSpanProcessor {
         }
         let interactions = fromMap.get(to);
         if (!interactions) {
-            interactions = { httpRequest: undefined, dbConnections: [], dbQueries: [] };
+            interactions = { httpRequest: undefined, dbConnections: [] };
             fromMap.set(to, interactions);
         }
         return interactions;
@@ -352,7 +374,6 @@ class ComprehendDevSpanProcessor {
     async forceFlush() {
     }
     async shutdown() {
-        this.connection.close();
     }
 }
 exports.ComprehendDevSpanProcessor = ComprehendDevSpanProcessor;
@@ -361,11 +382,36 @@ function hashIdString(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 getSpanContext(span) {
+    const ctx = span.spanContext?.();
+    return {
+        traceId: ctx?.traceId ?? '',
+        spanId: ctx?.spanId ?? '',
+    };
+}
+function getParentSpanId(span) {
+    return span.parentSpanContext?.spanId ?? '';
+}
+function flattenResourceAttributes(attrs) {
+    const result = {};
+    function flatten(obj, prefix) {
+        for (const [key, value] of Object.entries(obj)) {
+            const fullKey = prefix ? `${prefix}.${key}` : key;
+            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                flatten(value, fullKey);
+            }
+            else {
+                result[fullKey] = String(value);
+            }
+        }
+    }
+    flatten(attrs, '');
+    return result;
+}
+/** Try to extract data from the database connection string. Many are URL-based; falls back to
+ * semicolon-separated key=value parsing for the rest (e.g. MSSQL style). */
 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;
@@ -382,7 +428,6 @@ function parseDatabaseConnectionStringRaw(conn) {
         };
     }
     catch {
-        // Not a URL-style string; try semi-structured parsing
         const parts = conn.split(';');
         const kv = {};
         for (const part of parts) {
@@ -394,7 +439,6 @@ function parseDatabaseConnectionStringRaw(conn) {
         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}`)
@@ -408,11 +452,10 @@ function parseDatabaseConnectionStringRaw(conn) {
         };
     }
 }
-/** 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. */
+/** 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'];
@@ -422,7 +465,6 @@ function extractErrorInfo(span) {
             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'] ??
@@ -439,10 +481,27 @@ function extractErrorInfo(span) {
         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;
+function matchSpanRule(span, rule) {
+    switch (rule.kind) {
+        case 'type': {
+            const kindMap = {
+                'client': api_1.SpanKind.CLIENT,
+                'server': api_1.SpanKind.SERVER,
+                'internal': api_1.SpanKind.INTERNAL,
+            };
+            return span.kind === kindMap[rule.value];
+        }
+        case 'attribute-present':
+            return span.attributes[rule.key] !== undefined;
+        case 'attribute-absent':
+            return span.attributes[rule.key] === undefined;
+        case 'attribute-equals':
+            return String(span.attributes[rule.key]) === rule.value;
+        case 'attribute-not-equals':
+            return String(span.attributes[rule.key]) !== rule.value;
+        case 'all':
+            return rule.rules.every(r => matchSpanRule(span, r));
+        case 'any':
+            return rule.rules.some(r => matchSpanRule(span, r));
+    }
 }

package/dist/ComprehendDevSpanProcessor.test.d.ts

@@ -0,0 +1 @@
+export {};