@comprehend/telemetry-node 0.1.4 → 0.2.0

package/dist/ComprehendDevSpanProcessor.test.js

@@ -5,43 +5,31 @@ const ComprehendDevSpanProcessor_1 = require("./ComprehendDevSpanProcessor");
 const WebSocketConnection_1 = require("./WebSocketConnection");
 // Mock the WebSocketConnection
 jest.mock('./WebSocketConnection');
-// Mock the SQL analyzer
-jest.mock('./sql-analyzer', () => ({
-    analyzeSQL: jest.fn()
-}));
-const sql_analyzer_1 = require("./sql-analyzer");
-const mockedAnalyzeSQL = sql_analyzer_1.analyzeSQL;
 const MockedWebSocketConnection = WebSocketConnection_1.WebSocketConnection;
 describe('ComprehendDevSpanProcessor', () => {
     let processor;
     let mockConnection;
     let sentMessages;
+    let seqCounter;
     beforeEach(() => {
-        // Reset mocks
         MockedWebSocketConnection.mockClear();
-        mockedAnalyzeSQL.mockClear();
         sentMessages = [];
-        // Create mock connection instance
+        seqCounter = 1;
         mockConnection = {
             sendMessage: jest.fn((message) => {
                 sentMessages.push(message);
             }),
+            setProcessContext: jest.fn(),
+            nextSeq: jest.fn(() => seqCounter++),
             close: jest.fn()
         };
-        MockedWebSocketConnection.mockImplementation(() => mockConnection);
-        // Create processor instance
-        processor = new ComprehendDevSpanProcessor_1.ComprehendDevSpanProcessor({
-            organization: 'test-org',
-            token: 'test-token'
-        });
+        processor = new ComprehendDevSpanProcessor_1.ComprehendDevSpanProcessor(mockConnection);
     });
     afterEach(() => {
         processor.shutdown();
     });
-    // Helper function to create a mock span
     function createMockSpan(options = {}) {
-        const { name = 'test-span', kind = api_1.SpanKind.INTERNAL, attributes = {}, resourceAttributes = { 'service.name': 'test-service' }, status = { code: api_1.SpanStatusCode.OK }, events = [], startTime = [1700000000, 123456789], duration = [0, 100000000] // 100ms
-         } = options;
+        const { name = 'test-span', kind = api_1.SpanKind.INTERNAL, attributes = {}, resourceAttributes = { 'service.name': 'test-service' }, status = { code: api_1.SpanStatusCode.OK }, events = [], startTime = [1700000000, 123456789], duration = [0, 100000000], traceId = 'abc123trace', spanId = 'def456span', parentSpanId, } = options;
         return {
             name,
             kind,
@@ -56,7 +44,9 @@ describe('ComprehendDevSpanProcessor', () => {
                 time: startTime
             })),
             startTime,
-            duration
+            duration,
+            spanContext: () => ({ traceId, spanId, traceFlags: 1 }),
+            parentSpanContext: parentSpanId ? { spanId: parentSpanId, traceId: '', traceFlags: 0 } : undefined,
         };
     }
     describe('Service Discovery', () => {
@@ -69,52 +59,61 @@ describe('ComprehendDevSpanProcessor', () => {
                 }
             });
             processor.onEnd(span);
-            expect(sentMessages).toHaveLength(1);
-            expect(sentMessages[0]).toMatchObject({
+            const serviceMsg = sentMessages.find(m => m.event === 'new-entity' && m.type === 'service');
+            expect(serviceMsg).toMatchObject({
                 event: 'new-entity',
                 type: 'service',
                 name: 'my-api',
                 namespace: 'production',
                 environment: 'prod'
             });
-            expect(sentMessages[0].hash).toBeDefined();
+            expect(serviceMsg.hash).toBeDefined();
         });
         it('should not duplicate service registrations', () => {
-            const span1 = createMockSpan({
-                resourceAttributes: { 'service.name': 'my-api' }
-            });
-            const span2 = createMockSpan({
-                resourceAttributes: { 'service.name': 'my-api' }
-            });
+            const span1 = createMockSpan({ resourceAttributes: { 'service.name': 'my-api' } });
+            const span2 = createMockSpan({ resourceAttributes: { 'service.name': 'my-api' } });
             processor.onEnd(span1);
             processor.onEnd(span2);
-            // Should only send one service registration
             const serviceMessages = sentMessages.filter(m => m.event === 'new-entity' && m.type === 'service');
             expect(serviceMessages).toHaveLength(1);
         });
         it('should handle service without namespace and environment', () => {
-            const span = createMockSpan({
-                resourceAttributes: { 'service.name': 'simple-service' }
-            });
+            const span = createMockSpan({ resourceAttributes: { 'service.name': 'simple-service' } });
             processor.onEnd(span);
-            expect(sentMessages[0]).toMatchObject({
-                event: 'new-entity',
-                type: 'service',
-                name: 'simple-service'
-            });
-            expect(sentMessages[0]).not.toHaveProperty('namespace');
-            expect(sentMessages[0]).not.toHaveProperty('environment');
+            const serviceMsg = sentMessages.find(m => m.type === 'service');
+            expect(serviceMsg).toMatchObject({ name: 'simple-service' });
+            expect(serviceMsg).not.toHaveProperty('namespace');
+            expect(serviceMsg).not.toHaveProperty('environment');
         });
         it('should ignore spans without service.name', () => {
+            const span = createMockSpan({ resourceAttributes: {} });
+            processor.onEnd(span);
+            expect(sentMessages).toHaveLength(0);
+        });
+        it('should set process context on first service discovery', () => {
             const span = createMockSpan({
-                resourceAttributes: {}
+                resourceAttributes: {
+                    'service.name': 'my-api',
+                    'deployment.environment': 'prod',
+                }
             });
             processor.onEnd(span);
-            expect(sentMessages).toHaveLength(0);
+            expect(mockConnection.setProcessContext).toHaveBeenCalledTimes(1);
+            const [hash, resources] = mockConnection.setProcessContext.mock.calls[0];
+            expect(hash).toBeDefined();
+            expect(resources['service.name']).toBe('my-api');
+            expect(resources['deployment.environment']).toBe('prod');
+        });
+        it('should only set process context once', () => {
+            const span1 = createMockSpan({ resourceAttributes: { 'service.name': 'svc1' } });
+            const span2 = createMockSpan({ resourceAttributes: { 'service.name': 'svc2' } });
+            processor.onEnd(span1);
+            processor.onEnd(span2);
+            expect(mockConnection.setProcessContext).toHaveBeenCalledTimes(1);
         });
     });
     describe('HTTP Route Processing', () => {
-        it('should process HTTP server spans and create route entities', () => {
+        it('should process HTTP server spans with V2 observations (spanId, traceId)', () => {
             const span = createMockSpan({
                 kind: api_1.SpanKind.SERVER,
                 attributes: {
@@ -122,98 +121,29 @@ describe('ComprehendDevSpanProcessor', () => {
                     'http.method': 'GET',
                     'http.target': '/api/users/123',
                     'http.status_code': 200
-                }
+                },
+                traceId: 'trace-abc',
+                spanId: 'span-123',
             });
             processor.onEnd(span);
-            // Should have service + route messages
-            expect(sentMessages).toHaveLength(3); // service, route, observation
-            const routeMessage = sentMessages.find(m => m.type === 'http-route');
-            expect(routeMessage).toMatchObject({
-                event: 'new-entity',
-                type: 'http-route',
-                method: 'GET',
-                route: '/api/users/{id}'
-            });
             const observationMessage = sentMessages.find(m => m.event === 'observations');
-            expect(observationMessage.observations).toHaveLength(1);
             const observation = observationMessage.observations[0];
             expect(observation).toMatchObject({
                 type: 'http-server',
                 path: '/api/users/123',
-                status: 200
-            });
-        });
-        it('should extract path from http.url when http.target is not available', () => {
-            const span = createMockSpan({
-                kind: api_1.SpanKind.SERVER,
-                attributes: {
-                    'http.route': '/api/test',
-                    'http.method': 'POST',
-                    'http.url': 'https://example.com/api/test?param=value',
-                    'http.status_code': 201
-                }
-            });
-            processor.onEnd(span);
-            const observationMessage = sentMessages.find(m => m.event === 'observations');
-            const observation = observationMessage.observations[0];
-            expect(observation.path).toBe('/api/test');
-        });
-        it('should handle relative URLs in http.target', () => {
-            const span = createMockSpan({
-                kind: api_1.SpanKind.SERVER,
-                attributes: {
-                    'http.route': '/api/test',
-                    'http.method': 'GET',
-                    'http.target': 'invalid-url',
-                    'http.status_code': 400
-                }
-            });
-            processor.onEnd(span);
-            const observationMessage = sentMessages.find(m => m.event === 'observations');
-            const observation = observationMessage.observations[0];
-            // When used with placeholder base, 'invalid-url' becomes '/invalid-url'
-            expect(observation.path).toBe('/invalid-url');
-        });
-        it('should include optional HTTP attributes when present', () => {
-            const span = createMockSpan({
-                kind: api_1.SpanKind.SERVER,
-                attributes: {
-                    'http.route': '/api/upload',
-                    'http.method': 'POST',
-                    'http.target': '/api/upload',
-                    'http.status_code': 200,
-                    'http.flavor': '1.1',
-                    'http.user_agent': 'Mozilla/5.0',
-                    'http.request_content_length': 1024,
-                    'http.response_content_length': 256
-                }
-            });
-            processor.onEnd(span);
-            const observationMessage = sentMessages.find(m => m.event === 'observations');
-            const observation = observationMessage.observations[0];
-            expect(observation).toMatchObject({
-                httpVersion: '1.1',
-                userAgent: 'Mozilla/5.0',
-                requestBytes: 1024,
-                responseBytes: 256
+                status: 200,
+                spanId: 'span-123',
+                traceId: 'trace-abc',
             });
         });
         it('should not duplicate route registrations', () => {
             const span1 = createMockSpan({
                 kind: api_1.SpanKind.SERVER,
-                attributes: {
-                    'http.route': '/api/users',
-                    'http.method': 'GET',
-                    'http.status_code': 200
-                }
+                attributes: { 'http.route': '/api/users', 'http.method': 'GET', 'http.status_code': 200 }
             });
             const span2 = createMockSpan({
                 kind: api_1.SpanKind.SERVER,
-                attributes: {
-                    'http.route': '/api/users',
-                    'http.method': 'GET',
-                    'http.status_code': 200
-                }
+                attributes: { 'http.route': '/api/users', 'http.method': 'GET', 'http.status_code': 200 }
             });
             processor.onEnd(span1);
             processor.onEnd(span2);
@@ -222,96 +152,53 @@ describe('ComprehendDevSpanProcessor', () => {
         });
     });
     describe('HTTP Client Processing', () => {
-        it('should process HTTP client spans and create service entities and interactions', () => {
+        it('should process HTTP client spans with V2 observations', () => {
             const span = createMockSpan({
                 kind: api_1.SpanKind.CLIENT,
                 attributes: {
                     'http.url': 'https://api.external.com/v1/data',
                     'http.method': 'GET',
                     'http.status_code': 200
-                }
+                },
+                traceId: 'trace-xyz',
+                spanId: 'span-456',
             });
             processor.onEnd(span);
-            // Should have service + http-service + http-request + observation
-            expect(sentMessages).toHaveLength(4);
-            const httpServiceMessage = sentMessages.find(m => m.type === 'http-service');
-            expect(httpServiceMessage).toMatchObject({
-                event: 'new-entity',
-                type: 'http-service',
-                protocol: 'https',
-                host: 'api.external.com',
-                port: 443
-            });
-            const httpRequestMessage = sentMessages.find(m => m.type === 'http-request');
-            expect(httpRequestMessage).toMatchObject({
-                event: 'new-interaction',
-                type: 'http-request'
-            });
             const observationMessage = sentMessages.find(m => m.event === 'observations');
             const observation = observationMessage.observations[0];
             expect(observation).toMatchObject({
                 type: 'http-client',
                 path: '/v1/data',
                 method: 'GET',
-                status: 200
-            });
-        });
-        it('should handle HTTP on port 80 and HTTPS on port 443 correctly', () => {
-            const httpSpan = createMockSpan({
-                kind: api_1.SpanKind.CLIENT,
-                attributes: {
-                    'http.url': 'http://api.example.com/test',
-                    'http.method': 'GET'
-                }
-            });
-            processor.onEnd(httpSpan);
-            const httpServiceMessage = sentMessages.find(m => m.type === 'http-service');
-            expect(httpServiceMessage).toMatchObject({
-                protocol: 'http',
-                host: 'api.example.com',
-                port: 80
+                status: 200,
+                spanId: 'span-456',
+                traceId: 'trace-xyz',
             });
         });
-        it('should handle custom ports', () => {
+    });
+    describe('Database Processing', () => {
+        it('should send DatabaseQueryMessage for SQL queries (server-side analysis)', () => {
             const span = createMockSpan({
-                kind: api_1.SpanKind.CLIENT,
                 attributes: {
-                    'http.url': 'https://api.example.com:8443/test',
-                    'http.method': 'POST'
+                    'db.system': 'postgresql',
+                    'db.statement': 'SELECT * FROM users WHERE id = $1',
+                    'db.name': 'myapp',
+                    'net.peer.name': 'localhost',
+                    'db.response.returned_rows': 1
                 }
             });
             processor.onEnd(span);
-            const httpServiceMessage = sentMessages.find(m => m.type === 'http-service');
-            expect(httpServiceMessage).toMatchObject({
-                protocol: 'https',
-                host: 'api.example.com',
-                port: 8443
+            const dbQueryMsg = sentMessages.find(m => m.event === 'db-query');
+            expect(dbQueryMsg).toMatchObject({
+                event: 'db-query',
+                query: 'SELECT * FROM users WHERE id = $1',
+                returnedRows: 1,
             });
+            expect(dbQueryMsg.from).toBeDefined();
+            expect(dbQueryMsg.to).toBeDefined();
+            expect(dbQueryMsg.seq).toBeDefined();
         });
-        it('should not process client spans without http.method', () => {
-            const span = createMockSpan({
-                kind: api_1.SpanKind.CLIENT,
-                attributes: {
-                    'http.url': 'https://api.example.com/test'
-                    // Missing http.method
-                }
-            });
-            processor.onEnd(span);
-            // Should still create service and interaction, but no observation
-            const observationMessages = sentMessages.filter(m => m.event === 'observations');
-            expect(observationMessages).toHaveLength(0);
-        });
-    });
-    describe('Database Processing', () => {
-        beforeEach(() => {
-            // Setup SQL analyzer mock
-            mockedAnalyzeSQL.mockReturnValue({
-                tableOperations: { users: ['SELECT'] },
-                normalizedQuery: 'SELECT * FROM users',
-                presentableQuery: 'SELECT * FROM users'
-            });
-        });
-        it('should process database spans and create database entities', () => {
+        it('should create database entity and connection interaction', () => {
             const span = createMockSpan({
                 attributes: {
                     'db.system': 'postgresql',
@@ -330,112 +217,153 @@ describe('ComprehendDevSpanProcessor', () => {
                 host: 'db.example.com',
                 port: 5432
             });
-        });
-        it('should process database connection strings', () => {
-            const span = createMockSpan({
-                attributes: {
-                    'db.system': 'postgresql',
-                    'db.connection_string': 'postgresql://user:password@localhost:5432/testdb'
-                }
-            });
-            processor.onEnd(span);
-            const databaseMessage = sentMessages.find(m => m.type === 'database');
-            expect(databaseMessage).toMatchObject({
-                system: 'postgresql',
-                host: 'localhost',
-                port: 5432,
-                name: 'testdb'
-            });
             const connectionMessage = sentMessages.find(m => m.type === 'db-connection');
             expect(connectionMessage).toMatchObject({
                 event: 'new-interaction',
                 type: 'db-connection',
-                user: 'user'
             });
         });
-        it('should process SQL queries and create query interactions', () => {
+        it('should not send db-query for non-SQL database systems', () => {
             const span = createMockSpan({
                 attributes: {
-                    'db.system': 'postgresql',
-                    'db.statement': 'SELECT * FROM users WHERE id = $1',
-                    'db.name': 'myapp',
-                    'net.peer.name': 'localhost',
-                    'db.response.returned_rows': 1
+                    'db.system': 'mongodb',
+                    'db.statement': 'db.users.find({})',
+                    'db.name': 'myapp'
                 }
             });
             processor.onEnd(span);
-            expect(mockedAnalyzeSQL).toHaveBeenCalledWith('SELECT * FROM users WHERE id = $1');
-            const queryMessage = sentMessages.find(m => m.type === 'db-query');
-            expect(queryMessage).toMatchObject({
-                event: 'new-interaction',
-                type: 'db-query',
-                query: 'SELECT * FROM users',
-                selects: ['users']
-            });
-            const observationMessage = sentMessages.find(m => m.event === 'observations');
-            const observation = observationMessage.observations[0];
-            expect(observation).toMatchObject({
-                type: 'db-query',
-                returnedRows: 1
-            });
+            const dbQueryMessages = sentMessages.filter(m => m.event === 'db-query');
+            expect(dbQueryMessages).toHaveLength(0);
         });
-        it('should handle multiple table operations in SQL', () => {
-            mockedAnalyzeSQL.mockReturnValue({
-                tableOperations: {
-                    users: ['SELECT'],
-                    orders: ['INSERT'],
-                    products: ['UPDATE']
-                },
-                normalizedQuery: 'INSERT INTO orders SELECT * FROM users UPDATE products',
-                presentableQuery: 'INSERT INTO orders SELECT * FROM users UPDATE products'
-            });
+    });
+    describe('Trace Span Reporting', () => {
+        it('should send TraceSpansMessage for every span', () => {
             const span = createMockSpan({
+                name: 'GET /api/users',
+                kind: api_1.SpanKind.SERVER,
                 attributes: {
-                    'db.system': 'mysql',
-                    'db.statement': 'INSERT INTO orders SELECT * FROM users; UPDATE products SET stock = 0',
-                    'db.name': 'ecommerce'
-                }
+                    'http.route': '/api/users',
+                    'http.method': 'GET',
+                    'http.status_code': 200,
+                },
+                traceId: 'trace-001',
+                spanId: 'span-001',
+                parentSpanId: 'span-000',
             });
             processor.onEnd(span);
-            const queryMessage = sentMessages.find(m => m.type === 'db-query');
-            expect(queryMessage).toMatchObject({
-                selects: ['users'],
-                inserts: ['orders'],
-                updates: ['products']
+            const traceSpanMsg = sentMessages.find(m => m.event === 'tracespans');
+            expect(traceSpanMsg).toBeDefined();
+            expect(traceSpanMsg.data).toHaveLength(1);
+            expect(traceSpanMsg.data[0]).toMatchObject({
+                trace: 'trace-001',
+                span: 'span-001',
+                parent: 'span-000',
+                name: 'GET /api/users',
             });
         });
-        it('should not process SQL for non-SQL database systems', () => {
+        it('should use empty string for parent when no parentSpanId', () => {
             const span = createMockSpan({
-                attributes: {
-                    'db.system': 'mongodb',
-                    'db.statement': 'db.users.find({_id: ObjectId("...")}))',
-                    'db.name': 'myapp'
-                }
+                traceId: 'trace-root',
+                spanId: 'span-root',
+                // no parentSpanId
             });
             processor.onEnd(span);
-            expect(mockedAnalyzeSQL).not.toHaveBeenCalled();
-            // Should still create database and connection, but no query interaction
-            const queryMessages = sentMessages.filter(m => m.type === 'db-query');
-            expect(queryMessages).toHaveLength(0);
+            const traceSpanMsg = sentMessages.find(m => m.event === 'tracespans');
+            expect(traceSpanMsg.data[0].parent).toBe('');
         });
-        it('should handle alternative database connection string formats', () => {
+        it('should send trace span even for internal spans with no http/db attributes', () => {
             const span = createMockSpan({
-                attributes: {
-                    'db.system': 'mssql',
-                    'db.connection_string': 'Server=localhost;Database=TestDB;User Id=sa;Password=secret;'
-                }
+                name: 'internal-operation',
+                kind: api_1.SpanKind.INTERNAL,
             });
             processor.onEnd(span);
-            const databaseMessage = sentMessages.find(m => m.type === 'database');
-            expect(databaseMessage).toMatchObject({
-                system: 'mssql',
-                host: 'localhost',
-                name: 'TestDB'
+            const traceSpanMsg = sentMessages.find(m => m.event === 'tracespans');
+            expect(traceSpanMsg).toBeDefined();
+        });
+    });
+    describe('Custom Span Observation Matching', () => {
+        it('should match spans by type rule', () => {
+            processor.updateCustomMetrics([{
+                    type: 'span',
+                    rule: { kind: 'type', value: 'server' },
+                    subject: 'custom-server-obs',
+                }]);
+            const span = createMockSpan({
+                kind: api_1.SpanKind.SERVER,
+                attributes: {
+                    'http.route': '/test',
+                    'http.method': 'GET',
+                    'http.status_code': 200,
+                },
             });
-            const connectionMessage = sentMessages.find(m => m.type === 'db-connection');
-            expect(connectionMessage).toMatchObject({
-                user: 'sa'
+            processor.onEnd(span);
+            const customObs = sentMessages
+                .filter(m => m.event === 'observations')
+                .flatMap((m) => m.observations)
+                .find((o) => o.type === 'custom');
+            expect(customObs).toBeDefined();
+            expect(customObs.subject).toBe('custom-server-obs');
+            expect(customObs.id).toBe('custom-server-obs');
+            expect(customObs.attributes).toBeDefined();
+        });
+        it('should match spans by attribute-present rule', () => {
+            processor.updateCustomMetrics([{
+                    type: 'span',
+                    rule: { kind: 'attribute-present', key: 'custom.attr' },
+                    subject: 'has-custom-attr',
+                }]);
+            const spanWith = createMockSpan({ attributes: { 'custom.attr': 'value' } });
+            const spanWithout = createMockSpan({ attributes: {} });
+            processor.onEnd(spanWith);
+            processor.onEnd(spanWithout);
+            const customObs = sentMessages
+                .filter(m => m.event === 'observations')
+                .flatMap((m) => m.observations)
+                .filter((o) => o.type === 'custom');
+            expect(customObs).toHaveLength(1);
+        });
+        it('should match spans by compound all rule', () => {
+            processor.updateCustomMetrics([{
+                    type: 'span',
+                    rule: {
+                        kind: 'all',
+                        rules: [
+                            { kind: 'type', value: 'client' },
+                            { kind: 'attribute-equals', key: 'rpc.system', value: 'grpc' },
+                        ]
+                    },
+                    subject: 'grpc-client',
+                }]);
+            const matchingSpan = createMockSpan({
+                kind: api_1.SpanKind.CLIENT,
+                attributes: { 'rpc.system': 'grpc', 'http.url': 'http://x' },
             });
+            const nonMatchingSpan = createMockSpan({
+                kind: api_1.SpanKind.CLIENT,
+                attributes: { 'rpc.system': 'thrift' },
+            });
+            processor.onEnd(matchingSpan);
+            processor.onEnd(nonMatchingSpan);
+            const customObs = sentMessages
+                .filter(m => m.event === 'observations')
+                .flatMap((m) => m.observations)
+                .filter((o) => o.type === 'custom');
+            expect(customObs).toHaveLength(1);
+            expect(customObs[0].subject).toBe('grpc-client');
+        });
+        it('should not create custom observations when no specs match', () => {
+            processor.updateCustomMetrics([{
+                    type: 'span',
+                    rule: { kind: 'type', value: 'internal' },
+                    subject: 'internal-only',
+                }]);
+            const span = createMockSpan({ kind: api_1.SpanKind.SERVER });
+            processor.onEnd(span);
+            const customObs = sentMessages
+                .filter(m => m.event === 'observations')
+                .flatMap((m) => m.observations)
+                .filter((o) => o.type === 'custom');
+            expect(customObs).toHaveLength(0);
         });
     });
     describe('Error Handling', () => {
@@ -466,101 +394,28 @@ describe('ComprehendDevSpanProcessor', () => {
                 stack: 'Error at line 42\n  at method()'
             });
         });
-        it('should fallback to span attributes for error information', () => {
-            const span = createMockSpan({
-                kind: api_1.SpanKind.CLIENT,
-                attributes: {
-                    'http.url': 'https://api.example.com/fail',
-                    'http.method': 'POST',
-                    'http.status_code': 404,
-                    'exception.message': 'Not found',
-                    'exception.type': 'HttpError'
-                },
-                status: { code: api_1.SpanStatusCode.ERROR }
-            });
-            processor.onEnd(span);
-            const observationMessage = sentMessages.find(m => m.event === 'observations');
-            const observation = observationMessage.observations[0];
-            expect(observation).toMatchObject({
-                errorMessage: 'Not found',
-                errorType: 'HttpError'
-            });
-        });
-        it('should handle spans with error status but no explicit error attributes', () => {
-            const span = createMockSpan({
-                kind: api_1.SpanKind.SERVER,
-                attributes: {
-                    'http.route': '/api/timeout',
-                    'http.method': 'GET',
-                    'http.status_code': 500
-                },
-                status: { code: api_1.SpanStatusCode.ERROR, message: 'Request timeout' }
-            });
-            processor.onEnd(span);
-            const observationMessage = sentMessages.find(m => m.event === 'observations');
-            const observation = observationMessage.observations[0];
-            expect(observation.errorMessage).toBe('Request timeout');
-        });
     });
-    describe('Sequence Numbers and Batching', () => {
-        it('should increment sequence numbers for observation messages', () => {
+    describe('Sequence Numbers', () => {
+        it('should use connection.nextSeq() for observation messages', () => {
             const span1 = createMockSpan({
                 kind: api_1.SpanKind.SERVER,
-                attributes: {
-                    'http.route': '/api/test1',
-                    'http.method': 'GET',
-                    'http.status_code': 200
-                }
+                attributes: { 'http.route': '/api/test1', 'http.method': 'GET', 'http.status_code': 200 }
             });
             const span2 = createMockSpan({
                 kind: api_1.SpanKind.SERVER,
-                attributes: {
-                    'http.route': '/api/test2',
-                    'http.method': 'GET',
-                    'http.status_code': 200
-                }
+                attributes: { 'http.route': '/api/test2', 'http.method': 'GET', 'http.status_code': 200 }
             });
             processor.onEnd(span1);
             processor.onEnd(span2);
+            // nextSeq is called for observations AND tracespans
+            expect(mockConnection.nextSeq).toHaveBeenCalled();
             const observationMessages = sentMessages.filter(m => m.event === 'observations');
-            expect(observationMessages).toHaveLength(2);
-            expect(observationMessages[0].seq).toBe(1);
-            expect(observationMessages[1].seq).toBe(2);
+            // Each should have a unique seq
+            const seqs = observationMessages.map((m) => m.seq);
+            expect(new Set(seqs).size).toBe(seqs.length);
         });
     });
     describe('Processor Lifecycle', () => {
-        it('should construct with debug logging', () => {
-            const mockLogger = jest.fn();
-            const debugProcessor = new ComprehendDevSpanProcessor_1.ComprehendDevSpanProcessor({
-                organization: 'test-org',
-                token: 'test-token',
-                debug: mockLogger
-            });
-            expect(MockedWebSocketConnection).toHaveBeenCalledWith('test-org', 'test-token', mockLogger);
-            debugProcessor.shutdown();
-        });
-        it('should construct with debug enabled as boolean', () => {
-            const debugProcessor = new ComprehendDevSpanProcessor_1.ComprehendDevSpanProcessor({
-                organization: 'test-org',
-                token: 'test-token',
-                debug: true
-            });
-            expect(MockedWebSocketConnection).toHaveBeenCalledWith('test-org', 'test-token', console.log);
-            debugProcessor.shutdown();
-        });
-        it('should construct with debug disabled', () => {
-            const noDebugProcessor = new ComprehendDevSpanProcessor_1.ComprehendDevSpanProcessor({
-                organization: 'test-org',
-                token: 'test-token',
-                debug: false
-            });
-            expect(MockedWebSocketConnection).toHaveBeenCalledWith('test-org', 'test-token', undefined);
-            noDebugProcessor.shutdown();
-        });
-        it('should call connection.close() on shutdown', async () => {
-            await processor.shutdown();
-            expect(mockConnection.close).toHaveBeenCalled();
-        });
         it('should handle forceFlush without error', async () => {
             await expect(processor.forceFlush()).resolves.toBeUndefined();
         });
@@ -568,107 +423,73 @@ describe('ComprehendDevSpanProcessor', () => {
             expect(() => processor.onStart({}, {})).not.toThrow();
         });
     });
-    describe('Integration Tests', () => {
-        it('should handle a complete HTTP server request flow', () => {
-            const span = createMockSpan({
-                kind: api_1.SpanKind.SERVER,
-                attributes: {
-                    'http.route': '/api/users/{id}',
-                    'http.method': 'GET',
-                    'http.target': '/api/users/123?include=profile',
-                    'http.status_code': 200,
-                    'http.user_agent': 'test-client/1.0',
-                    'http.request_content_length': 0,
-                    'http.response_content_length': 456
-                },
-                resourceAttributes: {
-                    'service.name': 'user-api',
-                    'service.namespace': 'backend',
-                    'deployment.environment': 'staging'
-                },
-                startTime: [1700000000, 500000000],
-                duration: [0, 50000000] // 50ms
-            });
-            processor.onEnd(span);
-            // Verify all expected messages
-            expect(sentMessages).toHaveLength(3);
-            const serviceMessage = sentMessages[0];
-            expect(serviceMessage).toMatchObject({
-                event: 'new-entity',
-                type: 'service',
-                name: 'user-api',
-                namespace: 'backend',
-                environment: 'staging'
-            });
-            const routeMessage = sentMessages[1];
-            expect(routeMessage).toMatchObject({
-                event: 'new-entity',
-                type: 'http-route',
-                parent: serviceMessage.hash,
-                method: 'GET',
-                route: '/api/users/{id}'
-            });
-            const observationMessage = sentMessages[2];
-            expect(observationMessage.seq).toBe(1);
-            expect(observationMessage.observations).toHaveLength(1);
-            const observation = observationMessage.observations[0];
-            expect(observation).toMatchObject({
-                type: 'http-server',
-                subject: routeMessage.hash,
-                timestamp: [1700000000, 500000000],
-                path: '/api/users/123',
-                status: 200,
-                duration: [0, 50000000],
-                userAgent: 'test-client/1.0',
-                requestBytes: 0,
-                responseBytes: 456
-            });
-        });
-        it('should handle a complete database operation flow', () => {
-            mockedAnalyzeSQL.mockReturnValue({
-                tableOperations: { users: ['SELECT'], orders: ['INSERT'] },
-                normalizedQuery: 'INSERT INTO orders SELECT FROM users WHERE active = true',
-                presentableQuery: 'INSERT INTO orders SELECT FROM users WHERE active = true'
-            });
-            const span = createMockSpan({
-                attributes: {
-                    'db.system': 'postgresql',
-                    'db.connection_string': 'postgresql://app_user:secret@db.prod.com:5432/ecommerce',
-                    'db.statement': 'INSERT INTO orders SELECT FROM users WHERE active = true',
-                    'db.response.returned_rows': 5
-                },
-                startTime: [1700000000, 0],
-                duration: [0, 25000000] // 25ms
-            });
-            processor.onEnd(span);
-            // Verify all expected messages: service, database, connection, query, observation
-            expect(sentMessages).toHaveLength(5);
-            const databaseMessage = sentMessages.find(m => m.type === 'database');
-            expect(databaseMessage).toMatchObject({
-                system: 'postgresql',
-                host: 'db.prod.com',
-                port: 5432,
-                name: 'ecommerce'
-            });
-            const connectionMessage = sentMessages.find(m => m.type === 'db-connection');
-            expect(connectionMessage).toMatchObject({
-                user: 'app_user'
-            });
-            const queryMessage = sentMessages.find(m => m.type === 'db-query');
-            expect(queryMessage).toMatchObject({
-                query: 'INSERT INTO orders SELECT FROM users WHERE active = true',
-                selects: ['users'],
-                inserts: ['orders']
-            });
-            const observationMessage = sentMessages.find(m => m.event === 'observations');
-            const observation = observationMessage.observations[0];
-            expect(observation).toMatchObject({
-                type: 'db-query',
-                subject: queryMessage.hash,
-                timestamp: [1700000000, 0],
-                duration: [0, 25000000],
-                returnedRows: 5
-            });
-        });
+});
+describe('matchSpanRule', () => {
+    function createSpan(kind, attributes = {}) {
+        return {
+            kind,
+            attributes,
+            name: 'test',
+            spanContext: () => ({ traceId: '', spanId: '', traceFlags: 0 }),
+        };
+    }
+    it('should match type rule', () => {
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.SERVER), { kind: 'type', value: 'server' })).toBe(true);
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.CLIENT), { kind: 'type', value: 'server' })).toBe(false);
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.INTERNAL), { kind: 'type', value: 'internal' })).toBe(true);
+    });
+    it('should match attribute-present rule', () => {
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.INTERNAL, { 'foo': 'bar' }), { kind: 'attribute-present', key: 'foo' })).toBe(true);
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.INTERNAL, {}), { kind: 'attribute-present', key: 'foo' })).toBe(false);
+    });
+    it('should match attribute-absent rule', () => {
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.INTERNAL, {}), { kind: 'attribute-absent', key: 'foo' })).toBe(true);
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.INTERNAL, { 'foo': 'bar' }), { kind: 'attribute-absent', key: 'foo' })).toBe(false);
+    });
+    it('should match attribute-equals rule', () => {
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.INTERNAL, { 'k': 'v' }), { kind: 'attribute-equals', key: 'k', value: 'v' })).toBe(true);
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.INTERNAL, { 'k': 'other' }), { kind: 'attribute-equals', key: 'k', value: 'v' })).toBe(false);
+    });
+    it('should match attribute-not-equals rule', () => {
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.INTERNAL, { 'k': 'other' }), { kind: 'attribute-not-equals', key: 'k', value: 'v' })).toBe(true);
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.INTERNAL, { 'k': 'v' }), { kind: 'attribute-not-equals', key: 'k', value: 'v' })).toBe(false);
+    });
+    it('should match all rule', () => {
+        const rule = {
+            kind: 'all',
+            rules: [
+                { kind: 'type', value: 'server' },
+                { kind: 'attribute-present', key: 'http.route' },
+            ]
+        };
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.SERVER, { 'http.route': '/api' }), rule)).toBe(true);
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.SERVER, {}), rule)).toBe(false);
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.CLIENT, { 'http.route': '/api' }), rule)).toBe(false);
+    });
+    it('should match any rule', () => {
+        const rule = {
+            kind: 'any',
+            rules: [
+                { kind: 'type', value: 'server' },
+                { kind: 'type', value: 'client' },
+            ]
+        };
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.SERVER), rule)).toBe(true);
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.CLIENT), rule)).toBe(true);
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.INTERNAL), rule)).toBe(false);
+    });
+    it('should handle nested rules', () => {
+        const rule = {
+            kind: 'all',
+            rules: [
+                { kind: 'any', rules: [
+                        { kind: 'type', value: 'server' },
+                        { kind: 'type', value: 'client' },
+                    ] },
+                { kind: 'attribute-equals', key: 'rpc.system', value: 'grpc' },
+            ]
+        };
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.SERVER, { 'rpc.system': 'grpc' }), rule)).toBe(true);
+        expect((0, ComprehendDevSpanProcessor_1.matchSpanRule)(createSpan(api_1.SpanKind.INTERNAL, { 'rpc.system': 'grpc' }), rule)).toBe(false);
     });
 });