sdk-core, node: attribute validation

packages/node/src/attributes/ApplicationInformationAttributeProvider.ts

@@ -36,12 +36,6 @@ export class ApplicationInformationAttributeProvider implements BacktraceAttribu
             this._applicationVersion = this._applicationVersion ?? (applicationData['version'] as string);
         }
 
-        if (!this._application || !this._applicationVersion) {
-            throw new Error(
-                'Cannot find information about the package. Please define application and application.version attribute',
-            );
-        }
-
         return {
             package: applicationData,
             [this.APPLICATION_ATTRIBUTE]: this._application,

packages/sdk-core/src/BacktraceCoreClient.ts

@@ -218,6 +218,8 @@ export abstract class BacktraceCoreClient<
     }
 
     public initialize() {
+        this.validateAttributes();
+
         if (this.fileSystem && this.options.database?.createDatabaseDirectory) {
             if (!this.options.database.path) {
                 throw new Error(
@@ -418,4 +420,51 @@ export abstract class BacktraceCoreClient<
     private static destroy() {
         this._instance = undefined;
     }
+
+    private validateAttributes() {
+        function isNotEmptyString(v: unknown) {
+            if (typeof v === 'string' && v) {
+                return;
+            }
+
+            return 'must be defined and not an empty string';
+        }
+
+        const validators = {
+            application: isNotEmptyString,
+            'application.version': isNotEmptyString,
+        } as const;
+
+        function validate(attributes: Record<string, unknown>) {
+            const errors: Record<string, string> = {};
+            for (const [attribute, validate] of Object.entries(validators)) {
+                const value = attributes[attribute];
+                const error = validate(value);
+                if (error) {
+                    errors[attribute] = error;
+                }
+            }
+            return errors;
+        }
+
+        // Validate scoped attributes first. If they return no errors, there is no point
+        // in checking all attributes, which resolving of may be slower.
+        const scoped = this.attributeManager.get('scoped');
+        const scopedErrors = validate(scoped.attributes);
+        if (!Object.keys(scopedErrors).length) {
+            return;
+        }
+
+        const allAttributes = this.attributeManager.get();
+        const allErrors = validate(allAttributes.attributes);
+        if (!Object.keys(allErrors).length) {
+            return;
+        }
+
+        const attributeErrors = Object.entries(allErrors)
+            .map(([attribute, error]) => `${attribute}: ${error}`)
+            .join('\n');
+
+        throw new Error(`Following attributes are invalid:\n${attributeErrors}`);
+    }
 }

packages/sdk-core/tests/client/clientTests.spec.ts

@@ -1,6 +1,12 @@
 import { BacktraceReport, BacktraceStringAttachment } from '../../src/index.js';
+import { AttributeManager } from '../../src/modules/attribute/AttributeManager.js';
 import { BacktraceTestClient } from '../mocks/BacktraceTestClient.js';
+import { testHttpClient } from '../mocks/testHttpClient.js';
 describe('Client tests', () => {
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
     describe('Send tests', () => {
         const client = BacktraceTestClient.buildFakeClient();
 
@@ -128,4 +134,98 @@ describe('Client tests', () => {
             );
         });
     });
+
+    describe('Validation tests', () => {
+        it('should throw on initialize when application and application.version attributes are missing', () => {
+            const instance = new BacktraceTestClient({}, testHttpClient);
+            expect(() => instance.initialize()).toThrow(/application: must be defined and not an empty string/);
+            expect(() => instance.initialize()).toThrow(/application.version: must be defined and not an empty string/);
+        });
+
+        it('should throw on initialize when application attribute is missing', () => {
+            const instance = new BacktraceTestClient({}, testHttpClient, [
+                {
+                    type: 'scoped',
+                    get: () => ({
+                        'application.version': '1.2.3',
+                    }),
+                },
+            ]);
+            expect(() => instance.initialize()).toThrow(/application: must be defined and not an empty string/);
+        });
+
+        it('should throw on initialize when application.version attribute is missing', () => {
+            const instance = new BacktraceTestClient({}, testHttpClient, [
+                {
+                    type: 'scoped',
+                    get: () => ({
+                        application: 'my-app',
+                    }),
+                },
+            ]);
+            expect(() => instance.initialize()).toThrow(/application.version: must be defined and not an empty string/);
+        });
+
+        it('should not throw on initialize when application and application.version attributes are defined as scoped', () => {
+            const instance = new BacktraceTestClient({}, testHttpClient, [
+                {
+                    type: 'scoped',
+                    get: () => ({
+                        application: 'my-app',
+                        'application.version': '1.2.3',
+                    }),
+                },
+            ]);
+            expect(() => instance.initialize()).not.toThrow();
+        });
+
+        it('should not throw on initialize when application and application.version attributes are defined as dynamic', () => {
+            const instance = new BacktraceTestClient({}, testHttpClient, [
+                {
+                    type: 'dynamic',
+                    get: () => ({
+                        application: 'my-app',
+                        'application.version': '1.2.3',
+                    }),
+                },
+            ]);
+            expect(() => instance.initialize()).not.toThrow();
+        });
+
+        it('should only test scoped attributes and not all when application and application.version attributes are defined as scoped', () => {
+            const instance = new BacktraceTestClient({}, testHttpClient, [
+                {
+                    type: 'scoped',
+                    get: () => ({
+                        application: 'my-app',
+                        'application.version': '1.2.3',
+                    }),
+                },
+            ]);
+
+            const getAttributesSpy = jest.spyOn(AttributeManager.prototype, 'get');
+            instance.initialize();
+
+            expect(getAttributesSpy).toHaveBeenCalledWith('scoped');
+            expect(getAttributesSpy).not.toHaveBeenCalledWith();
+        });
+
+        it('should test both scoped attributes and all when application and application.version attributes are defined as dynamic', () => {
+            const instance = new BacktraceTestClient({}, testHttpClient, [
+                {
+                    type: 'dynamic',
+                    get: () => ({
+                        application: 'my-app',
+                        'application.version': '1.2.3',
+                    }),
+                },
+            ]);
+
+            const getAttributesSpy = jest.spyOn(AttributeManager.prototype, 'get');
+            instance.initialize();
+
+            expect(getAttributesSpy).toHaveBeenCalledWith('scoped');
+            expect(getAttributesSpy).toHaveBeenCalledWith();
+        });
+    });
 });