@comprehend/telemetry-node 0.1.4 → 0.2.0

package/src/ComprehendDevSpanProcessor.test.ts

@@ -1,6 +1,6 @@
 import { SpanKind, SpanStatusCode } from '@opentelemetry/api';
 import { ReadableSpan } from '@opentelemetry/sdk-trace-base';
-import { ComprehendDevSpanProcessor } from './ComprehendDevSpanProcessor';
+import { ComprehendDevSpanProcessor, matchSpanRule } from './ComprehendDevSpanProcessor';
 import { WebSocketConnection } from './WebSocketConnection';
 import {
     NewObservedServiceMessage,
@@ -9,60 +9,48 @@ import {
     NewObservedHttpServiceMessage,
     NewObservedHttpRequestMessage,
     NewObservedDatabaseConnectionMessage,
-    NewObservedDatabaseQueryMessage,
     ObservationMessage,
     HttpServerObservation,
     HttpClientObservation,
-    DatabaseQueryObservation,
-    ObservationInputMessage
+    DatabaseQueryMessage,
+    TraceSpansMessage,
+    CustomObservation,
+    ObservationInputMessage,
+    SpanMatcherRule,
 } from './wire-protocol';
 
 // Mock the WebSocketConnection
 jest.mock('./WebSocketConnection');
 
-// Mock the SQL analyzer
-jest.mock('./sql-analyzer', () => ({
-    analyzeSQL: jest.fn()
-}));
-
-import { analyzeSQL } from './sql-analyzer';
-
-const mockedAnalyzeSQL = analyzeSQL as jest.MockedFunction<typeof analyzeSQL>;
 const MockedWebSocketConnection = WebSocketConnection as jest.MockedClass<typeof WebSocketConnection>;
 
 describe('ComprehendDevSpanProcessor', () => {
     let processor: ComprehendDevSpanProcessor;
     let mockConnection: jest.Mocked<WebSocketConnection>;
     let sentMessages: any[];
+    let seqCounter: number;
 
     beforeEach(() => {
-        // Reset mocks
         MockedWebSocketConnection.mockClear();
-        mockedAnalyzeSQL.mockClear();
         sentMessages = [];
+        seqCounter = 1;
 
-        // Create mock connection instance
         mockConnection = {
             sendMessage: jest.fn((message: any) => {
                 sentMessages.push(message);
             }),
+            setProcessContext: jest.fn(),
+            nextSeq: jest.fn(() => seqCounter++),
             close: jest.fn()
         } as any;
 
-        MockedWebSocketConnection.mockImplementation(() => mockConnection);
-
-        // Create processor instance
-        processor = new ComprehendDevSpanProcessor({
-            organization: 'test-org',
-            token: 'test-token'
-        });
+        processor = new ComprehendDevSpanProcessor(mockConnection);
     });
 
     afterEach(() => {
         processor.shutdown();
     });
 
-    // Helper function to create a mock span
     function createMockSpan(options: {
         name?: string;
         kind?: SpanKind;
@@ -72,6 +60,9 @@ describe('ComprehendDevSpanProcessor', () => {
         events?: Array<{ name: string; attributes?: Record<string, any> }>;
         startTime?: [number, number];
         duration?: [number, number];
+        traceId?: string;
+        spanId?: string;
+        parentSpanId?: string;
     } = {}): ReadableSpan {
         const {
             name = 'test-span',
@@ -81,7 +72,10 @@ describe('ComprehendDevSpanProcessor', () => {
             status = { code: SpanStatusCode.OK },
             events = [],
             startTime = [1700000000, 123456789],
-            duration = [0, 100000000] // 100ms
+            duration = [0, 100000000],
+            traceId = 'abc123trace',
+            spanId = 'def456span',
+            parentSpanId,
         } = options;
 
         return {
@@ -98,8 +92,10 @@ describe('ComprehendDevSpanProcessor', () => {
                 time: startTime
             })),
             startTime,
-            duration
-        } as ReadableSpan;
+            duration,
+            spanContext: () => ({ traceId, spanId, traceFlags: 1 }),
+            parentSpanContext: parentSpanId ? { spanId: parentSpanId, traceId: '', traceFlags: 0 } : undefined,
+        } as any;
     }
 
     describe('Service Discovery', () => {
@@ -114,176 +110,110 @@ 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'
-            } as NewObservedServiceMessage);
-            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: {}
-            });
+            const span = createMockSpan({ resourceAttributes: {} });
 
             processor.onEnd(span);
 
             expect(sentMessages).toHaveLength(0);
         });
-    });
 
-    describe('HTTP Route Processing', () => {
-        it('should process HTTP server spans and create route entities', () => {
+        it('should set process context on first service discovery', () => {
             const span = createMockSpan({
-                kind: SpanKind.SERVER,
-                attributes: {
-                    'http.route': '/api/users/{id}',
-                    'http.method': 'GET',
-                    'http.target': '/api/users/123',
-                    'http.status_code': 200
+                resourceAttributes: {
+                    'service.name': 'my-api',
+                    'deployment.environment': 'prod',
                 }
             });
 
             processor.onEnd(span);
 
-            // Should have service + route messages
-            expect(sentMessages).toHaveLength(3); // service, route, observation
-            
-            const routeMessage = sentMessages.find(m => m.type === 'http-route') as NewObservedHttpRouteMessage;
-            expect(routeMessage).toMatchObject({
-                event: 'new-entity',
-                type: 'http-route',
-                method: 'GET',
-                route: '/api/users/{id}'
-            });
-
-            const observationMessage = sentMessages.find(m => m.event === 'observations') as ObservationMessage;
-            expect(observationMessage.observations).toHaveLength(1);
-            
-            const observation = observationMessage.observations[0] as HttpServerObservation;
-            expect(observation).toMatchObject({
-                type: 'http-server',
-                path: '/api/users/123',
-                status: 200
-            });
+            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 extract path from http.url when http.target is not available', () => {
-            const span = createMockSpan({
-                kind: SpanKind.SERVER,
-                attributes: {
-                    'http.route': '/api/test',
-                    'http.method': 'POST',
-                    'http.url': 'https://example.com/api/test?param=value',
-                    'http.status_code': 201
-                }
-            });
+        it('should only set process context once', () => {
+            const span1 = createMockSpan({ resourceAttributes: { 'service.name': 'svc1' } });
+            const span2 = createMockSpan({ resourceAttributes: { 'service.name': 'svc2' } });
 
-            processor.onEnd(span);
+            processor.onEnd(span1);
+            processor.onEnd(span2);
 
-            const observationMessage = sentMessages.find(m => m.event === 'observations') as ObservationMessage;
-            const observation = observationMessage.observations[0] as HttpServerObservation;
-            expect(observation.path).toBe('/api/test');
+            expect(mockConnection.setProcessContext).toHaveBeenCalledTimes(1);
         });
+    });
 
-        it('should handle relative URLs in http.target', () => {
+    describe('HTTP Route Processing', () => {
+        it('should process HTTP server spans with V2 observations (spanId, traceId)', () => {
             const span = createMockSpan({
                 kind: SpanKind.SERVER,
                 attributes: {
-                    'http.route': '/api/test',
+                    'http.route': '/api/users/{id}',
                     'http.method': 'GET',
-                    'http.target': 'invalid-url',
-                    'http.status_code': 400
-                }
-            });
-
-            processor.onEnd(span);
-
-            const observationMessage = sentMessages.find(m => m.event === 'observations') as ObservationMessage;
-            const observation = observationMessage.observations[0] as HttpServerObservation;
-            // 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: 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
-                }
+                    'http.target': '/api/users/123',
+                    'http.status_code': 200
+                },
+                traceId: 'trace-abc',
+                spanId: 'span-123',
             });
 
             processor.onEnd(span);
 
-            const observationMessage = sentMessages.find(m => m.event === 'observations') as ObservationMessage;
+            const observationMessage = sentMessages.find(m => m.event === 'observations');
             const observation = observationMessage.observations[0] as HttpServerObservation;
             expect(observation).toMatchObject({
-                httpVersion: '1.1',
-                userAgent: 'Mozilla/5.0',
-                requestBytes: 1024,
-                responseBytes: 256
+                type: 'http-server',
+                path: '/api/users/123',
+                status: 200,
+                spanId: 'span-123',
+                traceId: 'trace-abc',
             });
         });
 
         it('should not duplicate route registrations', () => {
             const span1 = createMockSpan({
                 kind: 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: 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);
@@ -295,112 +225,59 @@ 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: 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') as NewObservedHttpServiceMessage;
-            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') as NewObservedHttpRequestMessage;
-            expect(httpRequestMessage).toMatchObject({
-                event: 'new-interaction',
-                type: 'http-request'
-            });
-
-            const observationMessage = sentMessages.find(m => m.event === 'observations') as ObservationMessage;
+            const observationMessage = sentMessages.find(m => m.event === 'observations');
             const observation = observationMessage.observations[0] as HttpClientObservation;
             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: 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') as NewObservedHttpServiceMessage;
-            expect(httpServiceMessage).toMatchObject({
-                protocol: 'http',
-                host: 'api.example.com',
-                port: 80
-            });
-        });
-
-        it('should handle custom ports', () => {
-            const span = createMockSpan({
-                kind: SpanKind.CLIENT,
-                attributes: {
-                    'http.url': 'https://api.example.com:8443/test',
-                    'http.method': 'POST'
-                }
-            });
-
-            processor.onEnd(span);
-
-            const httpServiceMessage = sentMessages.find(m => m.type === 'http-service') as NewObservedHttpServiceMessage;
-            expect(httpServiceMessage).toMatchObject({
-                protocol: 'https',
-                host: 'api.example.com',
-                port: 8443
+                status: 200,
+                spanId: 'span-456',
+                traceId: 'trace-xyz',
             });
         });
+    });
 
-        it('should not process client spans without http.method', () => {
+    describe('Database Processing', () => {
+        it('should send DatabaseQueryMessage for SQL queries (server-side analysis)', () => {
             const span = createMockSpan({
-                kind: SpanKind.CLIENT,
                 attributes: {
-                    'http.url': 'https://api.example.com/test'
-                    // Missing http.method
+                    '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);
 
-            // 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'
+            const dbQueryMsg = sentMessages.find(m => m.event === 'db-query') as DatabaseQueryMessage;
+            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 process database spans and create database entities', () => {
+        it('should create database entity and connection interaction', () => {
             const span = createMockSpan({
                 attributes: {
                     'db.system': 'postgresql',
@@ -412,7 +289,7 @@ describe('ComprehendDevSpanProcessor', () => {
 
             processor.onEnd(span);
 
-            const databaseMessage = sentMessages.find(m => m.type === 'database') as NewObservedDatabaseMessage;
+            const databaseMessage = sentMessages.find(m => m.type === 'database');
             expect(databaseMessage).toMatchObject({
                 event: 'new-entity',
                 type: 'database',
@@ -421,133 +298,185 @@ 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') as NewObservedDatabaseMessage;
-            expect(databaseMessage).toMatchObject({
-                system: 'postgresql',
-                host: 'localhost',
-                port: 5432,
-                name: 'testdb'
-            });
 
-            const connectionMessage = sentMessages.find(m => m.type === 'db-connection') as NewObservedDatabaseConnectionMessage;
+            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 dbQueryMessages = sentMessages.filter(m => m.event === 'db-query');
+            expect(dbQueryMessages).toHaveLength(0);
+        });
+    });
 
-            const queryMessage = sentMessages.find(m => m.type === 'db-query') as NewObservedDatabaseQueryMessage;
-            expect(queryMessage).toMatchObject({
-                event: 'new-interaction',
-                type: 'db-query',
-                query: 'SELECT * FROM users',
-                selects: ['users']
+    describe('Trace Span Reporting', () => {
+        it('should send TraceSpansMessage for every span', () => {
+            const span = createMockSpan({
+                name: 'GET /api/users',
+                kind: SpanKind.SERVER,
+                attributes: {
+                    'http.route': '/api/users',
+                    'http.method': 'GET',
+                    'http.status_code': 200,
+                },
+                traceId: 'trace-001',
+                spanId: 'span-001',
+                parentSpanId: 'span-000',
             });
 
-            const observationMessage = sentMessages.find(m => m.event === 'observations') as ObservationMessage;
-            const observation = observationMessage.observations[0] as DatabaseQueryObservation;
-            expect(observation).toMatchObject({
-                type: 'db-query',
-                returnedRows: 1
-            });
-        });
+            processor.onEnd(span);
 
-        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'
+            const traceSpanMsg = sentMessages.find(m => m.event === 'tracespans') as TraceSpansMessage;
+            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 use empty string for parent when no parentSpanId', () => {
             const span = createMockSpan({
-                attributes: {
-                    'db.system': 'mysql',
-                    'db.statement': 'INSERT INTO orders SELECT * FROM users; UPDATE products SET stock = 0',
-                    'db.name': 'ecommerce'
-                }
+                traceId: 'trace-root',
+                spanId: 'span-root',
+                // no parentSpanId
             });
 
             processor.onEnd(span);
 
-            const queryMessage = sentMessages.find(m => m.type === 'db-query') as NewObservedDatabaseQueryMessage;
-            expect(queryMessage).toMatchObject({
-                selects: ['users'],
-                inserts: ['orders'],
-                updates: ['products']
-            });
+            const traceSpanMsg = sentMessages.find(m => m.event === 'tracespans') as TraceSpansMessage;
+            expect(traceSpanMsg.data[0].parent).toBe('');
         });
 
-        it('should not process SQL for non-SQL database systems', () => {
+        it('should send trace span even for internal spans with no http/db attributes', () => {
             const span = createMockSpan({
-                attributes: {
-                    'db.system': 'mongodb',
-                    'db.statement': 'db.users.find({_id: ObjectId("...")}))',
-                    'db.name': 'myapp'
-                }
+                name: 'internal-operation',
+                kind: SpanKind.INTERNAL,
             });
 
             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).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',
+            }]);
 
-        it('should handle alternative database connection string formats', () => {
             const span = createMockSpan({
+                kind: SpanKind.SERVER,
                 attributes: {
-                    'db.system': 'mssql',
-                    'db.connection_string': 'Server=localhost;Database=TestDB;User Id=sa;Password=secret;'
-                }
+                    'http.route': '/test',
+                    'http.method': 'GET',
+                    'http.status_code': 200,
+                },
             });
 
             processor.onEnd(span);
 
-            const databaseMessage = sentMessages.find(m => m.type === 'database') as NewObservedDatabaseMessage;
-            expect(databaseMessage).toMatchObject({
-                system: 'mssql',
-                host: 'localhost',
-                name: 'TestDB'
-            });
+            const customObs = sentMessages
+                .filter(m => m.event === 'observations')
+                .flatMap((m: ObservationMessage) => m.observations)
+                .find((o: any) => o.type === 'custom') as CustomObservation;
 
-            const connectionMessage = sentMessages.find(m => m.type === 'db-connection') as NewObservedDatabaseConnectionMessage;
-            expect(connectionMessage).toMatchObject({
-                user: 'sa'
+            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: ObservationMessage) => m.observations)
+                .filter((o: any) => 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: SpanKind.CLIENT,
+                attributes: { 'rpc.system': 'grpc', 'http.url': 'http://x' },
             });
+            const nonMatchingSpan = createMockSpan({
+                kind: SpanKind.CLIENT,
+                attributes: { 'rpc.system': 'thrift' },
+            });
+
+            processor.onEnd(matchingSpan);
+            processor.onEnd(nonMatchingSpan);
+
+            const customObs = sentMessages
+                .filter(m => m.event === 'observations')
+                .flatMap((m: ObservationMessage) => m.observations)
+                .filter((o: any) => 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: SpanKind.SERVER });
+            processor.onEnd(span);
+
+            const customObs = sentMessages
+                .filter(m => m.event === 'observations')
+                .flatMap((m: ObservationMessage) => m.observations)
+                .filter((o: any) => o.type === 'custom');
+
+            expect(customObs).toHaveLength(0);
         });
     });
 
@@ -573,126 +502,41 @@ describe('ComprehendDevSpanProcessor', () => {
 
             processor.onEnd(span);
 
-            const observationMessage = sentMessages.find(m => m.event === 'observations') as ObservationMessage;
-            const observation = observationMessage.observations[0] as HttpServerObservation;
+            const observationMessage = sentMessages.find(m => m.event === 'observations');
+            const observation = observationMessage.observations[0];
             expect(observation).toMatchObject({
                 errorMessage: 'Database connection failed',
                 errorType: 'ConnectionError',
                 stack: 'Error at line 42\n  at method()'
             });
         });
-
-        it('should fallback to span attributes for error information', () => {
-            const span = createMockSpan({
-                kind: 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: SpanStatusCode.ERROR }
-            });
-
-            processor.onEnd(span);
-
-            const observationMessage = sentMessages.find(m => m.event === 'observations') as ObservationMessage;
-            const observation = observationMessage.observations[0] as HttpClientObservation;
-            expect(observation).toMatchObject({
-                errorMessage: 'Not found',
-                errorType: 'HttpError'
-            });
-        });
-
-        it('should handle spans with error status but no explicit error attributes', () => {
-            const span = createMockSpan({
-                kind: SpanKind.SERVER,
-                attributes: {
-                    'http.route': '/api/timeout',
-                    'http.method': 'GET',
-                    'http.status_code': 500
-                },
-                status: { code: SpanStatusCode.ERROR, message: 'Request timeout' }
-            });
-
-            processor.onEnd(span);
-
-            const observationMessage = sentMessages.find(m => m.event === 'observations') as ObservationMessage;
-            const observation = observationMessage.observations[0] as HttpServerObservation;
-            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: 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: 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);
 
-            const observationMessages = sentMessages.filter(m => m.event === 'observations') as ObservationMessage[];
-            expect(observationMessages).toHaveLength(2);
-            expect(observationMessages[0].seq).toBe(1);
-            expect(observationMessages[1].seq).toBe(2);
+            // nextSeq is called for observations AND tracespans
+            expect(mockConnection.nextSeq).toHaveBeenCalled();
+
+            const observationMessages = sentMessages.filter(m => m.event === 'observations');
+            // Each should have a unique seq
+            const seqs = observationMessages.map((m: any) => 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({
-                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({
-                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({
-                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();
         });
@@ -701,122 +545,82 @@ describe('ComprehendDevSpanProcessor', () => {
             expect(() => processor.onStart({} as any, {} as any)).not.toThrow();
         });
     });
+});
 
-    describe('Integration Tests', () => {
-        it('should handle a complete HTTP server request flow', () => {
-            const span = createMockSpan({
-                kind: 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] as NewObservedServiceMessage;
-            expect(serviceMessage).toMatchObject({
-                event: 'new-entity',
-                type: 'service',
-                name: 'user-api',
-                namespace: 'backend',
-                environment: 'staging'
-            });
-
-            const routeMessage = sentMessages[1] as NewObservedHttpRouteMessage;
-            expect(routeMessage).toMatchObject({
-                event: 'new-entity',
-                type: 'http-route',
-                parent: serviceMessage.hash,
-                method: 'GET',
-                route: '/api/users/{id}'
-            });
-
-            const observationMessage = sentMessages[2] as ObservationMessage;
-            expect(observationMessage.seq).toBe(1);
-            expect(observationMessage.observations).toHaveLength(1);
-            
-            const observation = observationMessage.observations[0] as HttpServerObservation;
-            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
-            });
-        });
+describe('matchSpanRule', () => {
+    function createSpan(kind: SpanKind, attributes: Record<string, any> = {}): ReadableSpan {
+        return {
+            kind,
+            attributes,
+            name: 'test',
+            spanContext: () => ({ traceId: '', spanId: '', traceFlags: 0 }),
+        } as any;
+    }
 
-        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'
-            });
+    it('should match type rule', () => {
+        expect(matchSpanRule(createSpan(SpanKind.SERVER), { kind: 'type', value: 'server' })).toBe(true);
+        expect(matchSpanRule(createSpan(SpanKind.CLIENT), { kind: 'type', value: 'server' })).toBe(false);
+        expect(matchSpanRule(createSpan(SpanKind.INTERNAL), { kind: 'type', value: 'internal' })).toBe(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
-            });
+    it('should match attribute-present rule', () => {
+        expect(matchSpanRule(createSpan(SpanKind.INTERNAL, { 'foo': 'bar' }), { kind: 'attribute-present', key: 'foo' })).toBe(true);
+        expect(matchSpanRule(createSpan(SpanKind.INTERNAL, {}), { kind: 'attribute-present', key: 'foo' })).toBe(false);
+    });
 
-            processor.onEnd(span);
+    it('should match attribute-absent rule', () => {
+        expect(matchSpanRule(createSpan(SpanKind.INTERNAL, {}), { kind: 'attribute-absent', key: 'foo' })).toBe(true);
+        expect(matchSpanRule(createSpan(SpanKind.INTERNAL, { 'foo': 'bar' }), { kind: 'attribute-absent', key: 'foo' })).toBe(false);
+    });
 
-            // Verify all expected messages: service, database, connection, query, observation
-            expect(sentMessages).toHaveLength(5);
+    it('should match attribute-equals rule', () => {
+        expect(matchSpanRule(createSpan(SpanKind.INTERNAL, { 'k': 'v' }), { kind: 'attribute-equals', key: 'k', value: 'v' })).toBe(true);
+        expect(matchSpanRule(createSpan(SpanKind.INTERNAL, { 'k': 'other' }), { kind: 'attribute-equals', key: 'k', value: 'v' })).toBe(false);
+    });
 
-            const databaseMessage = sentMessages.find(m => m.type === 'database') as NewObservedDatabaseMessage;
-            expect(databaseMessage).toMatchObject({
-                system: 'postgresql',
-                host: 'db.prod.com',
-                port: 5432,
-                name: 'ecommerce'
-            });
+    it('should match attribute-not-equals rule', () => {
+        expect(matchSpanRule(createSpan(SpanKind.INTERNAL, { 'k': 'other' }), { kind: 'attribute-not-equals', key: 'k', value: 'v' })).toBe(true);
+        expect(matchSpanRule(createSpan(SpanKind.INTERNAL, { 'k': 'v' }), { kind: 'attribute-not-equals', key: 'k', value: 'v' })).toBe(false);
+    });
 
-            const connectionMessage = sentMessages.find(m => m.type === 'db-connection') as NewObservedDatabaseConnectionMessage;
-            expect(connectionMessage).toMatchObject({
-                user: 'app_user'
-            });
+    it('should match all rule', () => {
+        const rule: SpanMatcherRule = {
+            kind: 'all',
+            rules: [
+                { kind: 'type', value: 'server' },
+                { kind: 'attribute-present', key: 'http.route' },
+            ]
+        };
+        expect(matchSpanRule(createSpan(SpanKind.SERVER, { 'http.route': '/api' }), rule)).toBe(true);
+        expect(matchSpanRule(createSpan(SpanKind.SERVER, {}), rule)).toBe(false);
+        expect(matchSpanRule(createSpan(SpanKind.CLIENT, { 'http.route': '/api' }), rule)).toBe(false);
+    });
 
-            const queryMessage = sentMessages.find(m => m.type === 'db-query') as NewObservedDatabaseQueryMessage;
-            expect(queryMessage).toMatchObject({
-                query: 'INSERT INTO orders SELECT FROM users WHERE active = true',
-                selects: ['users'],
-                inserts: ['orders']
-            });
+    it('should match any rule', () => {
+        const rule: SpanMatcherRule = {
+            kind: 'any',
+            rules: [
+                { kind: 'type', value: 'server' },
+                { kind: 'type', value: 'client' },
+            ]
+        };
+        expect(matchSpanRule(createSpan(SpanKind.SERVER), rule)).toBe(true);
+        expect(matchSpanRule(createSpan(SpanKind.CLIENT), rule)).toBe(true);
+        expect(matchSpanRule(createSpan(SpanKind.INTERNAL), rule)).toBe(false);
+    });
 
-            const observationMessage = sentMessages.find(m => m.event === 'observations') as ObservationMessage;
-            const observation = observationMessage.observations[0] as DatabaseQueryObservation;
-            expect(observation).toMatchObject({
-                type: 'db-query',
-                subject: queryMessage.hash,
-                timestamp: [1700000000, 0],
-                duration: [0, 25000000],
-                returnedRows: 5
-            });
-        });
+    it('should handle nested rules', () => {
+        const rule: SpanMatcherRule = {
+            kind: 'all',
+            rules: [
+                { kind: 'any', rules: [
+                    { kind: 'type', value: 'server' },
+                    { kind: 'type', value: 'client' },
+                ]},
+                { kind: 'attribute-equals', key: 'rpc.system', value: 'grpc' },
+            ]
+        };
+        expect(matchSpanRule(createSpan(SpanKind.SERVER, { 'rpc.system': 'grpc' }), rule)).toBe(true);
+        expect(matchSpanRule(createSpan(SpanKind.INTERNAL, { 'rpc.system': 'grpc' }), rule)).toBe(false);
     });
-});
+});