@contrail/flexplm 1.8.1-alpha.85853aa → 2.0.0-alpha.9af4b96

package/lib/entity-processor/base-entity-processor.spec.js

@@ -6,6 +6,11 @@ const data_converter_1 = require("../util/data-converter");
 const base_entity_processor_1 = require("./base-entity-processor");
 const type_conversion_utils_1 = require("../util/type-conversion-utils");
 const thumbnail_util_1 = require("../util/thumbnail-util");
+const telemetry_test_utils_1 = require("../__tests__/telemetry-test-utils");
+const telemetry_attributes_1 = require("../util/telemetry-attributes");
+const event_short_message_status_1 = require("../util/event-short-message-status");
+const telemetry_1 = require("@contrail/telemetry");
+const api_1 = require("@opentelemetry/api");
 const mockRootType = {
     typeProperties: [
         { slug: 'rootText' }
@@ -663,4 +668,211 @@ describe('BaseEntityProcessor', () => {
             expect(mockEntitiesGet).toHaveBeenCalledTimes(1);
         });
     });
+    describe('telemetry', () => {
+        const config = {
+            apiHost: 'https://flexplm.example.com',
+            urlContext: '/FlexPLM',
+            vibeEventEndpoint: '/api/events',
+            csrfEndpoint: '/csrf',
+            plmEnviornment: 'test',
+            userName: () => 'user',
+            password: () => 'pass',
+            payloadDefaultAsArray: true,
+        };
+        const csrfResponse = () => ({ status: 200, json: jest.fn().mockResolvedValue({ items: [{ attributes: { nonce_key: 'K', nonce: 'N' } }] }) });
+        const sendResponse = (status = 200) => ({ status, json: jest.fn().mockResolvedValue({}), text: jest.fn().mockResolvedValue('error text') });
+        const outboundEvent = { entityType: 'item', eventType: 'update', id: 'item-1', newData: { flexPLMObjectClass: 'LCSProduct' } };
+        const inboundEvent = { objectClass: 'LCSProduct', federatedId: 'fed-1', data: {}, eventType: 'PERSIST' };
+        const globalFetch = global.fetch;
+        let exporter;
+        let btep;
+        let infoLog;
+        let warnLog;
+        let errorLog;
+        beforeAll(() => {
+            exporter = (0, telemetry_test_utils_1.registerInMemoryTracing)();
+        });
+        beforeEach(() => {
+            exporter.reset();
+            const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+            btep = new TestBaseEntityProcessor(config, new data_converter_1.DataConverter(config, mapFileUtil), mapFileUtil, 'item');
+            jest.spyOn(btep, 'getOutgoingUpsertPayload').mockResolvedValue({ objectClass: 'LCSProduct', data: {} });
+            infoLog = jest.spyOn(telemetry_1.logger, 'info').mockImplementation(() => undefined);
+            warnLog = jest.spyOn(telemetry_1.logger, 'warn').mockImplementation(() => undefined);
+            errorLog = jest.spyOn(telemetry_1.logger, 'error').mockImplementation(() => undefined);
+        });
+        afterEach(() => {
+            jest.restoreAllMocks();
+        });
+        afterAll(() => {
+            global.fetch = globalFetch;
+        });
+        it('should record send_to_flexplm as a child of process_outbound_entity', async () => {
+            global.fetch = jest.fn().mockResolvedValueOnce(csrfResponse()).mockResolvedValueOnce(sendResponse());
+            await btep.outbound(outboundEvent);
+            const outbound = (0, telemetry_test_utils_1.findSpan)(exporter, 'process_outbound_entity');
+            const upsert = (0, telemetry_test_utils_1.findSpan)(exporter, 'upsert_entity_in_flexplm');
+            const send = (0, telemetry_test_utils_1.findSpan)(exporter, 'send_to_flexplm');
+            expect(outbound.attributes[telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_TYPE]).toBe('item');
+            expect(outbound.attributes[telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_ID]).toBe('item-1');
+            expect(upsert.attributes[telemetry_attributes_1.ATTR_FLEXPLM_EVENT_OBJECT_CLASS]).toBe('LCSProduct');
+            expect((0, telemetry_test_utils_1.isChildOf)(upsert, outbound)).toBe(true);
+            expect((0, telemetry_test_utils_1.isChildOf)(send, upsert)).toBe(true);
+        });
+        it('should record a successful outbound status on the span and in one info log', async () => {
+            global.fetch = jest.fn().mockResolvedValueOnce(csrfResponse()).mockResolvedValueOnce(sendResponse());
+            await btep.outbound(outboundEvent);
+            const upsert = (0, telemetry_test_utils_1.findSpan)(exporter, 'upsert_entity_in_flexplm');
+            expect(upsert.attributes).toEqual(expect.objectContaining({
+                [telemetry_attributes_1.ATTR_FLEXPLM_STATUS]: event_short_message_status_1.EventShortMessageStatus.SUCCESS,
+                [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_ID]: 'item-1',
+                [telemetry_attributes_1.ATTR_FLEXPLM_UPDATED_FROM_RESPONSE]: false,
+            }));
+            expect(infoLog).toHaveBeenCalledTimes(1);
+            const flexplm = {
+                direction: 'outbound', status: event_short_message_status_1.EventShortMessageStatus.SUCCESS, entity_type: 'item', entity_id: 'item-1',
+                object_class: 'LCSProduct', http_status: 200, updated_from_response: false,
+            };
+            expect(infoLog).toHaveBeenCalledWith({ flexplm }, 'FlexPLM outbound entity sent: %j', flexplm);
+        });
+        it('should log an outbound failure with the error and rethrow it', async () => {
+            global.fetch = jest.fn().mockResolvedValueOnce(csrfResponse()).mockResolvedValueOnce(sendResponse(500));
+            await expect(btep.outbound(outboundEvent)).rejects.toThrow('Error sending data to FlexPLM:status: 500');
+            const upsert = (0, telemetry_test_utils_1.findSpan)(exporter, 'upsert_entity_in_flexplm');
+            expect(upsert.status.code).toBe(api_1.SpanStatusCode.ERROR);
+            expect(upsert.attributes[telemetry_attributes_1.ATTR_FLEXPLM_STATUS]).toBe(event_short_message_status_1.EventShortMessageStatus.FAILURE);
+            expect(errorLog).toHaveBeenCalledWith({
+                error: expect.any(Error),
+                flexplm: expect.objectContaining({ status: event_short_message_status_1.EventShortMessageStatus.FAILURE, entity_id: 'item-1', object_class: 'LCSProduct', http_status: 500 }),
+            }, 'FlexPLM outbound entity failed: %j', expect.any(Object));
+            expect(infoLog).not.toHaveBeenCalled();
+        });
+        it('should record an item FlexPLM rejected with HTTP 200 as a Failure warning and keep the span OK', async () => {
+            const rejectedResponse = { status: 200, json: jest.fn().mockResolvedValue({ payload: [{ status: 'FAIL' }] }) };
+            global.fetch = jest.fn().mockResolvedValueOnce(csrfResponse()).mockResolvedValueOnce(rejectedResponse);
+            const result = await btep.outbound(outboundEvent);
+            expect(result.status).toBe(200);
+            const upsert = (0, telemetry_test_utils_1.findSpan)(exporter, 'upsert_entity_in_flexplm');
+            expect(upsert.status.code).not.toBe(api_1.SpanStatusCode.ERROR);
+            expect(upsert.attributes).toEqual(expect.objectContaining({
+                [telemetry_attributes_1.ATTR_FLEXPLM_STATUS]: event_short_message_status_1.EventShortMessageStatus.FAILURE,
+                [telemetry_attributes_1.ATTR_FLEXPLM_RESPONSE_ITEM_STATUS]: 'FAIL',
+            }));
+            expect(warnLog).toHaveBeenCalledWith({ flexplm: expect.objectContaining({
+                    direction: 'outbound', status: event_short_message_status_1.EventShortMessageStatus.FAILURE, entity_id: 'item-1', http_status: 200, item_status: 'FAIL',
+                }) }, 'FlexPLM outbound entity rejected: %j', expect.any(Object));
+            expect(infoLog).not.toHaveBeenCalled();
+            expect(errorLog).not.toHaveBeenCalled();
+        });
+        it('should record an OK item status as a Success', async () => {
+            const okResponse = { status: 200, json: jest.fn().mockResolvedValue({ payload: [{ status: 'OK' }] }) };
+            global.fetch = jest.fn().mockResolvedValueOnce(csrfResponse()).mockResolvedValueOnce(okResponse);
+            jest.spyOn(btep, 'getOutboundEntityUpdates').mockResolvedValue(undefined);
+            await btep.outbound(outboundEvent);
+            const upsert = (0, telemetry_test_utils_1.findSpan)(exporter, 'upsert_entity_in_flexplm');
+            expect(upsert.attributes[telemetry_attributes_1.ATTR_FLEXPLM_STATUS]).toBe(event_short_message_status_1.EventShortMessageStatus.SUCCESS);
+            expect(upsert.attributes[telemetry_attributes_1.ATTR_FLEXPLM_RESPONSE_ITEM_STATUS]).toBe('OK');
+            expect(infoLog).toHaveBeenCalledWith({ flexplm: expect.objectContaining({ item_status: 'OK' }) }, 'FlexPLM outbound entity sent: %j', expect.any(Object));
+        });
+        it('should record an inbound No_Changes outcome on the span and in one info log', async () => {
+            jest.spyOn(btep, 'getTransformedData').mockResolvedValue({});
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: { id: 'existing-1' } });
+            jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({});
+            jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'syncInboundImages').mockResolvedValue(false);
+            await btep.inbound(inboundEvent);
+            const inbound = (0, telemetry_test_utils_1.findSpan)(exporter, 'process_inbound_entity');
+            expect(inbound.attributes).toEqual(expect.objectContaining({
+                [telemetry_attributes_1.ATTR_FLEXPLM_STATUS]: event_short_message_status_1.EventShortMessageStatus.SUCCESS,
+                [telemetry_attributes_1.ATTR_FLEXPLM_OUTCOME]: event_short_message_status_1.EventShortMessageStatus.NO_CHANGES,
+                [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_ID]: 'existing-1',
+                [telemetry_attributes_1.ATTR_FLEXPLM_FEDERATED_ID]: 'fed-1',
+            }));
+            expect(infoLog).toHaveBeenCalledTimes(1);
+            const flexplm = {
+                direction: 'inbound', status: event_short_message_status_1.EventShortMessageStatus.SUCCESS, outcome: event_short_message_status_1.EventShortMessageStatus.NO_CHANGES,
+                entity_type: 'item', entity_id: 'existing-1', object_class: 'LCSProduct', federated_id: 'fed-1',
+            };
+            expect(infoLog).toHaveBeenCalledWith({ flexplm }, 'FlexPLM inbound entity processed: %j', flexplm);
+        });
+        it('should record the created entity id on an inbound create', async () => {
+            jest.spyOn(btep, 'getTransformedData').mockResolvedValue({});
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: null });
+            jest.spyOn(btep, 'getCreateEntity').mockResolvedValue({ entity: { name: 'new' } });
+            jest.spyOn(btep, 'createEntity').mockResolvedValue({ id: 'created-1' });
+            jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'syncInboundImages').mockResolvedValue(false);
+            await btep.inbound(inboundEvent);
+            const inbound = (0, telemetry_test_utils_1.findSpan)(exporter, 'process_inbound_entity');
+            expect(inbound.attributes[telemetry_attributes_1.ATTR_FLEXPLM_OUTCOME]).toBe(event_short_message_status_1.EventShortMessageStatus.CREATED);
+            expect(inbound.attributes[telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_ID]).toBe('created-1');
+        });
+        it('should record the event type on the inbound and outbound spans', async () => {
+            jest.spyOn(btep, 'handleIncomingDelete').mockResolvedValue(undefined);
+            jest.spyOn(btep, 'handleOutgoingUpsert').mockResolvedValue(undefined);
+            await btep.inbound({ ...inboundEvent, eventType: 'DELETE' });
+            await btep.outbound(outboundEvent);
+            expect((0, telemetry_test_utils_1.findSpan)(exporter, 'process_inbound_entity').attributes[telemetry_attributes_1.ATTR_FLEXPLM_EVENT_TYPE]).toBe('DELETE');
+            expect((0, telemetry_test_utils_1.findSpan)(exporter, 'process_outbound_entity').attributes[telemetry_attributes_1.ATTR_FLEXPLM_EVENT_TYPE]).toBe('update');
+        });
+        it('should log unconfigured deletes as structured warnings without the event data', async () => {
+            await btep.inbound({ ...inboundEvent, eventType: 'DELETE', data: { secretField: 'inbound-value' } });
+            await btep.outbound({ ...outboundEvent, eventType: 'delete', oldData: { secretField: 'outbound-value' } });
+            expect(warnLog).toHaveBeenCalledWith({ flexplm: {
+                    direction: 'inbound', event_type: 'DELETE', entity_type: 'item', object_class: 'LCSProduct', federated_id: 'fed-1',
+                } }, 'FlexPLM delete is not configured');
+            expect(warnLog).toHaveBeenCalledWith({ flexplm: {
+                    direction: 'outbound', event_type: 'delete', entity_type: 'item', entity_id: 'item-1',
+                } }, 'FlexPLM delete is not configured');
+            expect(JSON.stringify(warnLog.mock.calls)).not.toMatch(/inbound-value|outbound-value/);
+        });
+        it('should record create_vibeiq_entity with the property count and created id', async () => {
+            jest.spyOn(sdk_1.Entities.prototype, 'create').mockResolvedValue({ id: 'created-1' });
+            await btep.createEntity('item', { name: 'n', color: 'red' });
+            const span = (0, telemetry_test_utils_1.findSpan)(exporter, 'create_vibeiq_entity');
+            expect(span.attributes).toEqual(expect.objectContaining({
+                [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_TYPE]: 'item', [telemetry_attributes_1.ATTR_FLEXPLM_CHANGED_PROPERTY_COUNT]: 2, [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_ID]: 'created-1',
+            }));
+        });
+        it('should record update_vibeiq_entity with the changed property count', async () => {
+            jest.spyOn(sdk_1.Entities.prototype, 'update').mockResolvedValue({ id: 'existing-1' });
+            await btep.updateEntity('item', { id: 'existing-1' }, { name: 'n' });
+            const span = (0, telemetry_test_utils_1.findSpan)(exporter, 'update_vibeiq_entity');
+            expect(span.attributes).toEqual(expect.objectContaining({
+                [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_ID]: 'existing-1', [telemetry_attributes_1.ATTR_FLEXPLM_CHANGED_PROPERTY_COUNT]: 1,
+            }));
+        });
+        it('should record whether get_entity_by_identity found the entity', async () => {
+            const get = jest.spyOn(btep['entities'], 'get')
+                .mockResolvedValueOnce([{ entityReference: 'item:abc' }]).mockResolvedValueOnce({ id: 'abc' })
+                .mockResolvedValueOnce([]);
+            const params = { poolKey: 'item', propertyName: 'itemNumber', propertyValue: '1' };
+            await btep.getEntityUsingIdentityService(params);
+            await btep.getEntityUsingIdentityService(params);
+            expect(get).toHaveBeenCalledTimes(3);
+            const [found, missing] = exporter.getFinishedSpans().filter(span => span.name === 'get_entity_by_identity');
+            expect(found.attributes[telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_FOUND]).toBe(true);
+            expect(missing.attributes[telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_FOUND]).toBe(false);
+        });
+        it('should record the result count of query_entities_by_criteria', async () => {
+            jest.spyOn(btep, 'getCriteriaForEntity').mockResolvedValue({ rootTypeCriteria: {}, subTypeCriteria: {} });
+            jest.spyOn(btep['dc'], 'getAllObjectReferences').mockResolvedValue([{ id: '1' }, { id: '2' }]);
+            await btep.queryEntityWithSubTypeCriteria('item', 'item', { itemNumber: '1' });
+            const span = (0, telemetry_test_utils_1.findSpan)(exporter, 'query_entities_by_criteria');
+            expect(span.attributes[telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_RESULT_COUNT]).toBe(2);
+        });
+        it('should log an inbound early return as a warning and keep the span OK', async () => {
+            jest.spyOn(btep, 'getTransformedData').mockResolvedValue({});
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({
+                earlyReturn: { status: 400, shortStatusMessage: event_short_message_status_1.EventShortMessageStatus.ITEM_FAMILY_NOT_FOUND },
+            });
+            await btep.inbound(inboundEvent);
+            const inbound = (0, telemetry_test_utils_1.findSpan)(exporter, 'process_inbound_entity');
+            expect(inbound.status.code).not.toBe(api_1.SpanStatusCode.ERROR);
+            expect(inbound.attributes[telemetry_attributes_1.ATTR_FLEXPLM_STATUS]).toBe(event_short_message_status_1.EventShortMessageStatus.FAILURE);
+            expect(inbound.attributes[telemetry_attributes_1.ATTR_FLEXPLM_OUTCOME]).toBe(event_short_message_status_1.EventShortMessageStatus.ITEM_FAMILY_NOT_FOUND);
+            expect(warnLog).toHaveBeenCalledWith({ flexplm: expect.objectContaining({
+                    direction: 'inbound', status: event_short_message_status_1.EventShortMessageStatus.FAILURE, outcome: event_short_message_status_1.EventShortMessageStatus.ITEM_FAMILY_NOT_FOUND,
+                }) }, 'FlexPLM inbound entity not processed: %j', expect.any(Object));
+            expect(infoLog).not.toHaveBeenCalled();
+        });
+    });
 });

package/lib/index.d.ts

@@ -21,3 +21,4 @@ export * from './publish/base-process-publish-assortment';
 export * from './publish/base-process-publish-assortment-callback';
 export * from './entity-processor/base-entity-processor';
 export * from './transform/identifier-conversion';
+export * from './util/telemetry-attributes';

package/lib/index.js

@@ -37,3 +37,4 @@ __exportStar(require("./publish/base-process-publish-assortment"), exports);
 __exportStar(require("./publish/base-process-publish-assortment-callback"), exports);
 __exportStar(require("./entity-processor/base-entity-processor"), exports);
 __exportStar(require("./transform/identifier-conversion"), exports);
+__exportStar(require("./util/telemetry-attributes"), exports);

package/lib/interfaces/interfaces.d.ts

@@ -1,5 +1,5 @@
 export interface FCConfig {
-    apiKey?: string;
+    apiKey?(): string;
     orgSlug?: string;
     action?: string;
     configFile?: string;

package/lib/publish/base-process-publish-assortment-callback.js

@@ -1,7 +1,19 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseProcessPublishAssortmentCallback = void 0;
 const sdk_1 = require("@contrail/sdk");
+const telemetry_1 = require("@contrail/telemetry");
+const telemetry_utils_1 = require("../util/telemetry-utils");
+const telemetry_attributes_1 = require("../util/telemetry-attributes");
 class BaseProcessPublishAssortmentCallback {
     constructor(_config) {
         this.config = _config;
@@ -21,7 +33,17 @@ class BaseProcessPublishAssortmentCallback {
     }
     async checkFailuresAndSendNotification(event) {
         const statusCounts = JSON.parse(this.config["statusCounts"]);
+        const failureCount = Number(statusCounts["FAILURE"]) || 0;
+        const invalidCount = Number(statusCounts["INVALID"]) || 0;
+        (0, telemetry_utils_1.setActiveSpanAttributes)({
+            [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_FAILURE_COUNT]: failureCount,
+            [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_INVALID_COUNT]: invalidCount,
+            [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_NOTIFICATION_SENT]: false,
+        });
+        // FlexPLM's per-item results for the publish; this is the only place they are reported.
+        const flexplm = { direction: 'publish', status_counts: statusCounts, failure_count: failureCount, invalid_count: invalidCount };
         if (statusCounts["INVALID"] > 0 || statusCounts["FAILURE"] > 0) {
+            telemetry_1.logger.warn({ flexplm }, 'FlexPLM publish had failed items: %j', flexplm);
             await new sdk_1.Notification().Dispatch({
                 message: `There were errors when publishing the season data. Please review the event and config information from context.`,
                 level: sdk_1.LogLevel.WARN,
@@ -30,9 +52,17 @@ class BaseProcessPublishAssortmentCallback {
                     config: this.config,
                 },
             });
+            (0, telemetry_utils_1.setActiveSpanAttributes)({ [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_NOTIFICATION_SENT]: true });
             return 'sent notification';
         }
+        telemetry_1.logger.info({ flexplm }, 'FlexPLM publish items processed: %j', flexplm);
         return 'no notification needed';
     }
 }
 exports.BaseProcessPublishAssortmentCallback = BaseProcessPublishAssortmentCallback;
+__decorate([
+    (0, telemetry_1.Traced)("process_publish_callback"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], BaseProcessPublishAssortmentCallback.prototype, "process", null);

package/lib/publish/base-process-publish-assortment-callback.spec.d.ts

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

package/lib/publish/base-process-publish-assortment-callback.spec.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const telemetry_1 = require("@contrail/telemetry");
+const base_process_publish_assortment_callback_1 = require("./base-process-publish-assortment-callback");
+const telemetry_test_utils_1 = require("../__tests__/telemetry-test-utils");
+const telemetry_attributes_1 = require("../util/telemetry-attributes");
+const mockDispatch = jest.fn();
+jest.mock('@contrail/sdk', () => ({
+    ...jest.requireActual('@contrail/sdk'),
+    Notification: jest.fn().mockImplementation(() => ({ Dispatch: mockDispatch })),
+}));
+describe('BaseProcessPublishAssortmentCallback telemetry', () => {
+    let exporter;
+    let infoLog;
+    let warnLog;
+    const process = (statusCounts) => new base_process_publish_assortment_callback_1.BaseProcessPublishAssortmentCallback({ statusCounts: JSON.stringify(statusCounts) }).process({});
+    beforeAll(() => {
+        exporter = (0, telemetry_test_utils_1.registerInMemoryTracing)();
+    });
+    beforeEach(() => {
+        exporter.reset();
+        mockDispatch.mockReset().mockResolvedValue(undefined);
+        infoLog = jest.spyOn(telemetry_1.logger, 'info').mockImplementation(() => undefined);
+        warnLog = jest.spyOn(telemetry_1.logger, 'warn').mockImplementation(() => undefined);
+    });
+    afterEach(() => {
+        // Not restoreAllMocks: that would also clear the Notification mock implementation above.
+        infoLog.mockRestore();
+        warnLog.mockRestore();
+    });
+    it('should record the failure counts, warn and mark the notification sent', async () => {
+        const result = await process({ SUCCESS: 5, FAILURE: 2, INVALID: 1 });
+        expect(result.message).toContain('sent notification');
+        const span = (0, telemetry_test_utils_1.findSpan)(exporter, 'process_publish_callback');
+        expect(span.attributes).toEqual(expect.objectContaining({
+            [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_FAILURE_COUNT]: 2,
+            [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_INVALID_COUNT]: 1,
+            [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_NOTIFICATION_SENT]: true,
+        }));
+        expect(warnLog).toHaveBeenCalledWith({ flexplm: {
+                direction: 'publish', status_counts: { SUCCESS: 5, FAILURE: 2, INVALID: 1 }, failure_count: 2, invalid_count: 1,
+            } }, 'FlexPLM publish had failed items: %j', expect.any(Object));
+        expect(infoLog).not.toHaveBeenCalled();
+    });
+    it('should record zero counts and an info log when every item succeeded', async () => {
+        await process({ SUCCESS: 5 });
+        const span = (0, telemetry_test_utils_1.findSpan)(exporter, 'process_publish_callback');
+        expect(span.attributes).toEqual(expect.objectContaining({
+            [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_FAILURE_COUNT]: 0,
+            [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_INVALID_COUNT]: 0,
+            [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_NOTIFICATION_SENT]: false,
+        }));
+        expect(mockDispatch).not.toHaveBeenCalled();
+        expect(infoLog).toHaveBeenCalledWith({ flexplm: expect.objectContaining({ failure_count: 0 }) }, 'FlexPLM publish items processed: %j', expect.any(Object));
+    });
+    it('should not mark the notification sent when dispatching it fails', async () => {
+        mockDispatch.mockRejectedValue(new Error('notification service down'));
+        await expect(process({ FAILURE: 1 })).rejects.toThrow('notification service down');
+        const span = (0, telemetry_test_utils_1.findSpan)(exporter, 'process_publish_callback');
+        expect(span.attributes[telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_NOTIFICATION_SENT]).toBe(false);
+    });
+});

package/lib/publish/base-process-publish-assortment.d.ts

@@ -3,6 +3,21 @@ import { DataConverter } from '../util/data-converter';
 import { ItemFamilyChanges } from '../interfaces/item-family-changes';
 import { PublishChangeData } from '../interfaces/publish-change-data';
 import { MapFileUtil } from '@contrail/transform-data';
+import { EventShortMessageStatus } from '../util/event-short-message-status';
+export interface PublishStatus {
+    status: EventShortMessageStatus;
+    assortmentId: string;
+    assortmentPublishChangeId: string;
+    resultsCount?: {
+        productSeasons: number;
+        colorwaySeasons: number;
+    };
+    /** Why the publish was skipped, for the expected skip statuses. */
+    message?: string;
+    /** FlexPLM accepted the publish, but the external-event that records it could not be created. */
+    sentUnrecorded?: boolean;
+    error?: unknown;
+}
 export declare class BaseProcessPublishAssortment {
     private TTL;
     static ASSORTMENT_NOT_PUBLISHABLE: string;
@@ -31,6 +46,10 @@ export declare class BaseProcessPublishAssortment {
         resultsCount: any;
         skip_await?: undefined;
     }>;
+    /** Records the result of one assortment publish: attributes on the active span plus one structured log.
+     * Not_Publishable / No_Federation_Information are handled skips, so the span stays OK for them.
+     */
+    protected recordPublishStatus(statusObject: PublishStatus): void;
     getPublishInfo(assortmentId: string, assortmentPublishChangeId: string, apcHistory: any, publisher: any): Promise<any>;
     /** Gets the version number of the snapshot that was created for the publish change.
      * But if no snapshot was found for the publish change, and the last snapshot was
@@ -54,7 +73,12 @@ export declare class BaseProcessPublishAssortment {
     downloadAssortmentPublishChange(assortmentId: string, assortmentPublishChangeId: string): Promise<any>;
     downloadHydratedChangeDetail(assortmentPublishChange: any): Promise<any>;
     downloadAssortmentBaseline(assortmentPublishChange: any): Promise<any>;
+    /** Downloads one publish file as JSON. Returns undefined when it can't be read, so the publish continues without it;
+     * the span is marked ERROR here because nothing is thrown. The link is never recorded (it is a signed URL).
+     */
+    private downloadPublishFile;
     getDeleteChanges(assortmentPublishChange: any, apcHistory: any[], assortmentBaseline: any, sinceDate: Date): Promise<[]>;
+    private collectDeleteChanges;
     getBaselineItemIds(assortmentBaseline: any): string[];
     downloadDeleteChanges(apc: any): Promise<any>;
     buildDeleteChanges(apc: any, previousApc: any): Promise<any>;