@contrail/flexplm 1.8.1 → 2.0.0-alpha.c9d1df5

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

@@ -10,6 +10,11 @@ const type_conversion_utils_1 = require("../util/type-conversion-utils");
 const map_utils_1 = require("../util/map-utils");
 const item_family_changes_1 = require("../interfaces/item-family-changes");
 const flexplm_connect_1 = require("../util/flexplm-connect");
+const telemetry_1 = require("@contrail/telemetry");
+const api_1 = require("@opentelemetry/api");
+const telemetry_test_utils_1 = require("../__tests__/telemetry-test-utils");
+const event_short_message_status_1 = require("../util/event-short-message-status");
+const telemetry_attributes_1 = require("../util/telemetry-attributes");
 let federatedId = '';
 jest.mock('../util/data-converter', () => {
     return {
@@ -2211,3 +2216,186 @@ describe('released family with pre-development options', () => {
         expect(await ppa.getEventsForItemFamilyChanges(ifc, 'a1', eventSeasonFed, new Map())).toHaveLength(0);
     });
 });
+describe('publish status telemetry', () => {
+    const config = {};
+    const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+    const pcd = { assortmentId: 'a1', assortmentPublishChangeId: 'apc1' };
+    let exporter;
+    let ppa;
+    let infoLog;
+    let warnLog;
+    let errorLog;
+    beforeAll(() => {
+        exporter = (0, telemetry_test_utils_1.registerInMemoryTracing)();
+    });
+    beforeEach(() => {
+        exporter.reset();
+        federatedId = '';
+        entityObject = { publishToFlexPLM: true };
+        ppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(config, new data_converter_1.DataConverter(config, mapFileUtil), mapFileUtil);
+        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();
+    });
+    const stubProcessPublish = (events) => {
+        jest.spyOn(ppa, 'getFullChangeAssortmentMap').mockReturnValue(new Map());
+        jest.spyOn(ppa, 'getDeleteChangesAssortmentMap').mockReturnValue(new Map());
+        jest.spyOn(ppa, 'getItemFamilyChanges').mockReturnValue(new Map());
+        jest.spyOn(ppa, 'getEventsForPublishChangeData').mockResolvedValue(events);
+        jest.spyOn(ppa, 'sendEvents').mockResolvedValue({});
+    };
+    it('should record No_Federation_Information as a warning and keep the span OK', async () => {
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierProperties').mockImplementation(async () => ['flexPLMSeasonName']);
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getInformationalProperties').mockImplementation(async () => ['name']);
+        await ppa.process({ assortmentId: 'a1', assortmentPublishChangeId: 'apc1' });
+        const span = (0, telemetry_test_utils_1.findSpan)(exporter, 'publish_assortment');
+        expect(span.status.code).not.toBe(api_1.SpanStatusCode.ERROR);
+        expect(span.attributes).toEqual(expect.objectContaining({
+            [telemetry_attributes_1.ATTR_FLEXPLM_STATUS]: event_short_message_status_1.EventShortMessageStatus.NO_FEDERATION_INFO,
+            [telemetry_attributes_1.ATTR_FLEXPLM_ASSORTMENT_ID]: 'a1',
+            [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_CHANGE_ID]: 'apc1',
+        }));
+        expect(warnLog).toHaveBeenCalledTimes(1);
+        expect(warnLog).toHaveBeenCalledWith({ flexplm: expect.objectContaining({
+                direction: 'publish', status: event_short_message_status_1.EventShortMessageStatus.NO_FEDERATION_INFO, assortment_id: 'a1', publish_change_id: 'apc1',
+                reason: expect.stringContaining(base_process_publish_assortment_1.BaseProcessPublishAssortment.ASSORTMENT_NO_FED_INFO),
+            }) }, 'FlexPLM assortment publish skipped');
+    });
+    it('should log No_Events_to_Send as an info log', async () => {
+        stubProcessPublish([]);
+        const result = await (0, telemetry_1.traceSection)('test', {}, () => ppa.processPublish(pcd, {}, {}, []));
+        expect(result['skip_await']).toBe(true);
+        expect(infoLog).toHaveBeenCalledWith({ flexplm: expect.objectContaining({
+                status: event_short_message_status_1.EventShortMessageStatus.NO_EVENTS_TO_SEND, assortment_id: 'a1', publish_change_id: 'apc1',
+            }) }, 'FlexPLM assortment publish processed');
+    });
+    it('should record the sent event counts on the span and in the info log', async () => {
+        stubProcessPublish([{ objectClass: 'LCSProductSeasonLink' }]);
+        await (0, telemetry_1.traceSection)('test', {}, () => ppa.processPublish(pcd, {}, {}, []));
+        const span = (0, telemetry_test_utils_1.findSpan)(exporter, 'test');
+        expect(span.attributes).toEqual(expect.objectContaining({
+            [telemetry_attributes_1.ATTR_FLEXPLM_STATUS]: event_short_message_status_1.EventShortMessageStatus.SENDING_EVENTS,
+            [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_PRODUCT_SEASON_COUNT]: 1,
+            [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_COLORWAY_SEASON_COUNT]: 0,
+        }));
+        expect(infoLog).toHaveBeenCalledWith({ flexplm: expect.objectContaining({
+                status: event_short_message_status_1.EventShortMessageStatus.SENDING_EVENTS, product_season_count: 1, colorway_season_count: 0,
+            }) }, 'FlexPLM assortment publish processed');
+    });
+    it('should mark a failed publish file download as an error span and return undefined', async () => {
+        const globalFetch = global.fetch;
+        global.fetch = jest.fn().mockResolvedValue({ ok: false, status: 403, json: jest.fn() });
+        try {
+            const result = await ppa.downloadHydratedChangeDetail({ hydratedDetailDownloadLink: 'https://signed.example/detail?sig=secret' });
+            expect(result).toBeUndefined();
+            const span = (0, telemetry_test_utils_1.findSpan)(exporter, 'download_publish_file');
+            expect(span.status.code).toBe(api_1.SpanStatusCode.ERROR);
+            expect(span.attributes).toEqual(expect.objectContaining({ [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_FILE]: 'hydrated_detail', 'http.response.status_code': 403 }));
+            expect(JSON.stringify(span.attributes)).not.toContain('secret');
+            expect(errorLog).toHaveBeenCalledWith({
+                error: expect.any(Error), flexplm: { direction: 'publish', publish_file: 'hydrated_detail', http_status: 403 },
+            }, 'FlexPLM publish file download failed');
+        }
+        finally {
+            global.fetch = globalFetch;
+        }
+    });
+    it('should record failed downloads on the publish span instead of zero counts', async () => {
+        jest.spyOn(ppa, 'getSeasonFederation').mockResolvedValue({});
+        jest.spyOn(ppa, 'getApcHistory').mockResolvedValue([]);
+        jest.spyOn(ppa, 'getSinceDate').mockResolvedValue(new Date());
+        jest.spyOn(ppa, 'downloadAssortmentPublishChange').mockResolvedValue({ createdBy: {} });
+        jest.spyOn(ppa, 'downloadHydratedChangeDetail').mockResolvedValue(undefined);
+        jest.spyOn(ppa, 'downloadAssortmentBaseline').mockResolvedValue({});
+        jest.spyOn(ppa, 'getDeleteChanges').mockResolvedValue([]);
+        jest.spyOn(ppa, 'getReleasedForDevelopmentItemAndFamilyIds').mockReturnValue([]);
+        jest.spyOn(ppa, 'processPublish').mockResolvedValue({});
+        jest.spyOn(ppa, 'getPublishInfo').mockResolvedValue({});
+        await ppa.process({ assortmentId: 'a1', assortmentPublishChangeId: 'apc1' });
+        const span = (0, telemetry_test_utils_1.findSpan)(exporter, 'publish_assortment');
+        expect(span.attributes[telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_FAILED_DOWNLOADS]).toEqual(['hydrated_detail']);
+        expect(span.attributes[telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_ADDED_COUNT]).toBeUndefined();
+    });
+    it('should record the send mode and warn when it is unknown', async () => {
+        ppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment({ sendMode: {} }, new data_converter_1.DataConverter(config, mapFileUtil), mapFileUtil);
+        const result = await (0, telemetry_1.traceSection)('test', {}, () => ppa.sendEvents([{}, {}]));
+        expect(result).toEqual({});
+        expect((0, telemetry_test_utils_1.findSpan)(exporter, 'test').attributes[telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_SEND_MODE]).toBe('');
+        expect(warnLog).toHaveBeenCalledWith({ flexplm: { direction: 'publish', send_mode: '', payload_count: 2 } }, 'Unknown FlexPLM publish sendMode; events not sent');
+    });
+    it('should log a publish FlexPLM accepted but that was not recorded as sent_unrecorded', async () => {
+        const failure = new Error('external-event create failed');
+        failure.sendToFlexPLMResult = { status: 200 };
+        failure.sendPublishPayloadEventResult = { error: failure.message };
+        jest.spyOn(ppa, 'getSeasonFederation').mockResolvedValue({});
+        jest.spyOn(ppa, 'getApcHistory').mockRejectedValue(failure);
+        jest.spyOn(ppa, 'getPublishInfo').mockResolvedValue({});
+        await expect(ppa.process({ assortmentId: 'a1', assortmentPublishChangeId: 'apc1' })).rejects.toBe(failure);
+        const span = (0, telemetry_test_utils_1.findSpan)(exporter, 'publish_assortment');
+        expect(span.attributes[telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_SENT_UNRECORDED]).toBe(true);
+        expect(errorLog).toHaveBeenCalledWith({
+            error: failure, flexplm: expect.objectContaining({ status: event_short_message_status_1.EventShortMessageStatus.FAILURE, sent_unrecorded: true }),
+        }, 'FlexPLM assortment publish sent but not recorded');
+    });
+    it('should record the history count on get_publish_history', async () => {
+        sdk_1.Request.request = jest.fn().mockResolvedValue([{ id: 'apc1' }, { id: 'apc2' }]);
+        try {
+            await ppa.getApcHistory('a1');
+        }
+        finally {
+            delete sdk_1.Request.request;
+        }
+        expect((0, telemetry_test_utils_1.findSpan)(exporter, 'get_publish_history').attributes[telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_HISTORY_COUNT]).toBe(2);
+    });
+    it('should record the delete change count on get_delete_changes', async () => {
+        jest.spyOn(ppa, 'downloadDeleteChanges').mockResolvedValue([{ itemId: 'i1' }, { itemId: 'i2' }]);
+        const apcHistory = [{ id: 'apc0', createdOn: '2026-01-01' }, { id: 'apc1', createdOn: '2026-02-01' }];
+        const deletes = await ppa.getDeleteChanges({ id: 'apc1' }, apcHistory, { assortmentItems: [] }, new Date('2026-01-01'));
+        expect(deletes).toHaveLength(2);
+        const span = (0, telemetry_test_utils_1.findSpan)(exporter, 'get_delete_changes');
+        expect(span.attributes[telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_DELETE_CHANGE_COUNT]).toBe(2);
+    });
+    it('should record item family and payload counts on build_publish_events', async () => {
+        const changes = new Map([['fam1', {}], ['fam2', {}]]);
+        jest.spyOn(ppa, 'getEventsForItemFamilyChanges')
+            .mockResolvedValueOnce([{}, {}]).mockResolvedValueOnce([{}]);
+        const events = await ppa.getEventsForPublishChangeData({ ...pcd, itemFamilyChanges: changes });
+        expect(events).toHaveLength(3);
+        const span = (0, telemetry_test_utils_1.findSpan)(exporter, 'build_publish_events');
+        expect(span.attributes).toEqual(expect.objectContaining({
+            [telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_ITEM_FAMILY_COUNT]: 2, [telemetry_attributes_1.ATTR_FLEXPLM_PAYLOAD_COUNT]: 3,
+        }));
+    });
+    it('should count skipped deletes with no item entity and log one warning for the publish', async () => {
+        const releasedPcd = {
+            assortmentId: 'a1', assortmentPublishChangeId: 'apc1', sinceDate: new Date(), itemToFederatedIdMapping: new Map(),
+            // A deleted entry without its item has no family id; it is only in scope if that undefined id is.
+            releasedForDevelopmentItemIds: [undefined, 'opt1'],
+        };
+        const emptyDetail = { adds: [], deletes: [], updates: [], familyItemsRemoved: [] };
+        await (0, telemetry_1.traceSection)('test', {}, async () => ppa.getItemFamilyChanges(releasedPcd, emptyDetail, new Map(), new Map([['opt1', { itemId: 'opt1' }]])));
+        expect((0, telemetry_test_utils_1.findSpan)(exporter, 'test').attributes[telemetry_attributes_1.ATTR_FLEXPLM_PUBLISH_SKIPPED_DELETE_COUNT]).toBe(1);
+        expect(warnLog).toHaveBeenCalledTimes(1);
+        expect(warnLog).toHaveBeenCalledWith({ flexplm: expect.objectContaining({
+                assortment_id: 'a1', skipped_delete_count: 1, skipped_deletes: [{ item_family_id: undefined, item_id: 'opt1' }],
+            }) }, 'FlexPLM publish skipped deleted items with no item entity');
+    });
+    it('should log a failed publish with the error and rethrow it', async () => {
+        const failure = new Error('apc history unavailable');
+        jest.spyOn(ppa, 'getSeasonFederation').mockResolvedValue({});
+        jest.spyOn(ppa, 'getApcHistory').mockRejectedValue(failure);
+        jest.spyOn(ppa, 'getPublishInfo').mockResolvedValue({});
+        await expect(ppa.process({ assortmentId: 'a1', assortmentPublishChangeId: 'apc1' })).rejects.toBe(failure);
+        const span = (0, telemetry_test_utils_1.findSpan)(exporter, 'publish_assortment');
+        expect(span.status.code).toBe(api_1.SpanStatusCode.ERROR);
+        expect(span.attributes[telemetry_attributes_1.ATTR_FLEXPLM_STATUS]).toBe(event_short_message_status_1.EventShortMessageStatus.FAILURE);
+        expect(errorLog).toHaveBeenCalledWith({
+            error: failure,
+            flexplm: expect.objectContaining({ status: event_short_message_status_1.EventShortMessageStatus.FAILURE, assortment_id: 'a1', publish_change_id: 'apc1' }),
+        }, 'FlexPLM assortment publish failed');
+        expect(infoLog).not.toHaveBeenCalled();
+    });
+});

package/lib/util/error-response-object.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorResponseObject = void 0;
 const app_framework_1 = require("@contrail/app-framework");
+const telemetry_1 = require("@contrail/telemetry");
 class ErrorResponseObject {
     /** Returns a response, checking for multiple possible error details
      *
@@ -48,6 +49,7 @@ class ErrorResponseObject {
         if (e.stack) {
             console.log('ErrorResponseObject.getResponse stack: ' + e.stack);
         }
+        telemetry_1.logger.error({ error: e }, 'FlexPLM action failed');
         return response;
     }
 }

package/lib/util/event-short-message-status.js

@@ -21,4 +21,4 @@ var EventShortMessageStatus;
     EventShortMessageStatus["NO_FEDERATION_INFO"] = "No_Federation_Information";
     EventShortMessageStatus["NO_EVENTS_TO_SEND"] = "No_Events_to_Send";
     EventShortMessageStatus["SENDING_EVENTS"] = "Sending_Events";
-})(EventShortMessageStatus = exports.EventShortMessageStatus || (exports.EventShortMessageStatus = {}));
+})(EventShortMessageStatus || (exports.EventShortMessageStatus = EventShortMessageStatus = {}));

package/lib/util/flexplm-connect.d.ts

@@ -12,6 +12,10 @@ export declare class FlexPLMConnect {
      * and the check-then-register in runColdAcquisition has to stay synchronous to be race free.
      */
     private waitForInFlightAcquisition;
+    /** Marks the active span when this request is about to wait for another request's cold acquisition.
+     * Synchronous on purpose: it must not add an await to the wait loops (see waitForInFlightAcquisition).
+     */
+    private recordWaitForInFlightAcquisition;
     /** Runs a cold acquisition and registers it so concurrent callers wait for it instead of opening their own session. */
     private runColdAcquisition;
     private getSessionKey;