ci: smoke test setTraceAttributes

wrn14897 · wrn14897 · commit e3b4662bc06c · 2025-11-11T18:50:07.000-05:00
diff --git a/Makefile b/Makefile
@@ -39,7 +39,13 @@ smoke-sdk-http-ts-programmaticImports: build-smoke-images smoke-tests/collector/
 	@echo ""
 	cd smoke-tests && bats ./smoke-sdk-http-ts-programmaticImports.bats --report-formatter junit --output ./ --verbose-run
 
-smoke-sdk: smoke-sdk-http-ts smoke-sdk-grpc-ts
+smoke-setTraceAttributes: build-smoke-images smoke-tests/collector/data.json
+	@echo ""
+	@echo "+++ Running setTraceAttributes smoke tests for TypeScript."
+	@echo ""
+	cd smoke-tests && bats ./smoke-setTraceAttributes.bats --report-formatter junit --output ./ --verbose-run
+
+smoke-sdk: smoke-sdk-http-ts smoke-sdk-grpc-ts smoke-setTraceAttributes
 
 smoke: docker_compose_present
 	@echo ""
@@ -56,7 +62,7 @@ unsmoke: docker_compose_present
 #: use this for local smoke testing
 resmoke: unsmoke smoke
 
-.PHONY: clean-smoke-tests build-smoke-images example smoke unsmoke resmoke smoke-sdk-grpc-ts smoke-sdk-http-ts smoke-sdk-http-ts-programmaticImports smoke-sdk
+.PHONY: clean-smoke-tests build-smoke-images example smoke unsmoke resmoke smoke-sdk-grpc-ts smoke-sdk-http-ts smoke-sdk-http-ts-programmaticImports smoke-setTraceAttributes smoke-sdk
 
 .PHONY: docker_compose_present
 docker_compose_present:
diff --git a/smoke-tests/hello-node-express-ts/README.md b/smoke-tests/hello-node-express-ts/README.md
@@ -34,3 +34,49 @@ You can now curl the app:
 curl localhost:3000
 Hello, World!
 ```
+
+### Testing setTraceAttributes API
+
+A comprehensive smoke test endpoint is available at `/test-trace-attributes` that tests various scenarios for the `setTraceAttributes` API.
+
+#### Manual testing
+
+```bash
+curl localhost:3000/test-trace-attributes
+```
+
+#### Automated smoke tests with BATS
+
+Run the complete BATS smoke test suite (includes Docker Compose setup):
+
+```bash
+# From the root of the repository
+make smoke-setTraceAttributes
+
+# Or run all smoke tests including setTraceAttributes
+make smoke-sdk
+```
+
+These tests will:
+- Build Docker images for the app
+- Start the collector and app containers
+- Execute the `/test-trace-attributes` endpoint
+- Verify that trace attributes are correctly captured in telemetry data
+- Check attribute isolation between concurrent spans
+- Validate attribute types and special characters
+
+#### Test coverage
+
+This endpoint tests:
+1. **Basic attribute setting** - Simple string attributes
+2. **Multiple attribute types** - Strings, numbers, booleans, and arrays
+3. **Nested spans** - Attributes in parent, child, and grandchild spans
+4. **Overwriting attributes** - Setting the same key multiple times
+5. **Special characters** - Keys with dots, hyphens, and spaces
+6. **Empty attributes** - Empty objects
+7. **Large number of attributes** - 50+ attributes
+8. **Concurrent spans** - Multiple concurrent spans with different attributes
+9. **Async operations** - Attributes before and after async operations
+10. **Null/undefined values** - Handling of null and undefined attribute values
+
+The response will include a JSON object with test results and confirmation that all tests completed successfully.
diff --git a/smoke-tests/hello-node-express-ts/index.ts b/smoke-tests/hello-node-express-ts/index.ts
@@ -122,6 +122,206 @@ app.get('/logs', (_req: Request, res: Response) => {
   res.status(200).json({ message: 'Logs generated successfully' });
 });
 
+// Smoke test endpoint for setTraceAttributes API
+// eslint-disable-next-line @typescript-eslint/no-misused-promises
+app.get(
+  '/test-trace-attributes',
+  async (_req: Request, res: Response, next: NextFunction) => {
+    try {
+      const tracer: Tracer = trace.getTracer('trace-attributes-test');
+      const results: { [key: string]: string } = {};
+
+      // Test 1: Basic attribute setting
+      await tracer.startActiveSpan('test-basic-attributes', (span: Span) => {
+        HyperDX.setTraceAttributes({
+          userId: 'user-123',
+          requestId: 'req-456',
+          testName: 'basic-attributes',
+        });
+        pinoLogger.info('Test 1: Set basic trace attributes');
+        results.test1 = 'basic-attributes-set';
+        span.end();
+      });
+
+      // Test 2: Multiple attribute types
+      await tracer.startActiveSpan('test-multiple-types', (span: Span) => {
+        HyperDX.setTraceAttributes({
+          stringAttr: 'value',
+          numberAttr: 42,
+          booleanAttr: true,
+          arrayAttr: ['a', 'b', 'c'],
+          testName: 'multiple-types',
+        });
+        pinoLogger.info('Test 2: Set multiple attribute types');
+        results.test2 = 'multiple-types-set';
+        span.end();
+      });
+
+      // Test 3: Nested spans with attributes
+      await tracer.startActiveSpan('test-nested-spans', async (parentSpan) => {
+        HyperDX.setTraceAttributes({
+          level: 'parent',
+          testName: 'nested-spans',
+        });
+        pinoLogger.info('Test 3: Parent span attributes');
+
+        await tracer.startActiveSpan('child-span', async (childSpan) => {
+          HyperDX.setTraceAttributes({
+            level: 'child',
+            childId: 'child-1',
+          });
+          pinoLogger.info('Test 3: Child span attributes');
+
+          await tracer.startActiveSpan('grandchild-span', (grandchildSpan) => {
+            HyperDX.setTraceAttributes({
+              level: 'grandchild',
+              grandchildId: 'grandchild-1',
+            });
+            pinoLogger.info('Test 3: Grandchild span attributes');
+            grandchildSpan.end();
+          });
+
+          childSpan.end();
+        });
+
+        results.test3 = 'nested-spans-set';
+        parentSpan.end();
+      });
+
+      // Test 4: Setting attributes multiple times (overwrite)
+      await tracer.startActiveSpan('test-overwrite', (span: Span) => {
+        HyperDX.setTraceAttributes({
+          key: 'value1',
+          testName: 'overwrite',
+        });
+        HyperDX.setTraceAttributes({
+          key: 'value2', // This should overwrite the previous value
+          additionalKey: 'additional-value',
+        });
+        pinoLogger.info('Test 4: Overwrite attributes');
+        results.test4 = 'overwrite-set';
+        span.end();
+      });
+
+      // Test 5: Attributes with special characters
+      await tracer.startActiveSpan('test-special-chars', (span: Span) => {
+        HyperDX.setTraceAttributes({
+          'user.id': 'user-123',
+          'request-id': 'req-456',
+          'foo.bar.baz': 'nested-key',
+          'key with spaces': 'value with spaces',
+          testName: 'special-chars',
+        });
+        pinoLogger.info('Test 5: Special characters in attribute keys');
+        results.test5 = 'special-chars-set';
+        span.end();
+      });
+
+      // Test 6: Empty attributes
+      await tracer.startActiveSpan('test-empty-attributes', (span: Span) => {
+        HyperDX.setTraceAttributes({});
+        pinoLogger.info('Test 6: Empty attributes object');
+        results.test6 = 'empty-attributes-set';
+        span.end();
+      });
+
+      // Test 7: Large number of attributes
+      await tracer.startActiveSpan('test-many-attributes', (span: Span) => {
+        const manyAttributes: { [key: string]: string } = {
+          testName: 'many-attributes',
+        };
+        for (let i = 0; i < 50; i++) {
+          manyAttributes[`attr${i}`] = `value${i}`;
+        }
+        HyperDX.setTraceAttributes(manyAttributes);
+        pinoLogger.info('Test 7: Large number of attributes (50)');
+        results.test7 = 'many-attributes-set';
+        span.end();
+      });
+
+      // Test 8: Concurrent attribute setting
+      await Promise.all([
+        tracer.startActiveSpan('concurrent-1', async (span) => {
+          HyperDX.setTraceAttributes({
+            spanId: '1',
+            value: 'concurrent-a',
+            testName: 'concurrent-1',
+          });
+          pinoLogger.info('Test 8: Concurrent span 1');
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          span.end();
+        }),
+        tracer.startActiveSpan('concurrent-2', async (span) => {
+          HyperDX.setTraceAttributes({
+            spanId: '2',
+            value: 'concurrent-b',
+            testName: 'concurrent-2',
+          });
+          pinoLogger.info('Test 8: Concurrent span 2');
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          span.end();
+        }),
+        tracer.startActiveSpan('concurrent-3', async (span) => {
+          HyperDX.setTraceAttributes({
+            spanId: '3',
+            value: 'concurrent-c',
+            testName: 'concurrent-3',
+          });
+          pinoLogger.info('Test 8: Concurrent span 3');
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          span.end();
+        }),
+      ]);
+      results.test8 = 'concurrent-attributes-set';
+
+      // Test 9: Attributes in async operations
+      await tracer.startActiveSpan('test-async', async (span) => {
+        HyperDX.setTraceAttributes({
+          stage: 'before-async',
+          testName: 'async',
+        });
+        pinoLogger.info('Test 9: Before async operation');
+
+        await new Promise((resolve) => setTimeout(resolve, 20));
+
+        HyperDX.setTraceAttributes({
+          stage: 'after-async',
+        });
+        pinoLogger.info('Test 9: After async operation');
+
+        results.test9 = 'async-attributes-set';
+        span.end();
+      });
+
+      // Test 10: Attributes with null/undefined values
+      await tracer.startActiveSpan('test-null-undefined', (span: Span) => {
+        HyperDX.setTraceAttributes({
+          nullAttr: null as any,
+          undefinedAttr: undefined as any,
+          validAttr: 'valid',
+          testName: 'null-undefined',
+        });
+        pinoLogger.info('Test 10: Null and undefined values');
+        results.test10 = 'null-undefined-set';
+        span.end();
+      });
+
+      pinoLogger.info(
+        { results },
+        'All setTraceAttributes smoke tests completed',
+      );
+      res.status(200).json({
+        message: 'setTraceAttributes smoke tests completed successfully',
+        results,
+        testsRun: Object.keys(results).length,
+      });
+    } catch (err) {
+      pinoLogger.error({ err }, 'Error in setTraceAttributes smoke tests');
+      next(err);
+    }
+  },
+);
+
 function sleepy(): Promise<void> {
   return new Promise((resolve) => {
     setTimeout(() => {
diff --git a/smoke-tests/smoke-setTraceAttributes.bats b/smoke-tests/smoke-setTraceAttributes.bats
