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

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

@@ -8,10 +8,17 @@ const sdk_1 = require("@contrail/sdk");
 const type_conversion_utils_1 = require("../util/type-conversion-utils");
 const thumbnail_util_1 = require("../util/thumbnail-util");
 const event_short_message_status_1 = require("../util/event-short-message-status");
+const telemetry_1 = require("@contrail/telemetry");
+const telemetry_utils_1 = require("../util/telemetry-utils");
+const telemetry_attributes_1 = require("../util/telemetry-attributes");
 const UNSUPPORTED_TYPE = 'Unsupported eventType.';
 class IncomingEntityResponse {
 }
 exports.IncomingEntityResponse = IncomingEntityResponse;
+const FLEXPLM_ITEM_STATUS_OK = 'OK';
+const hasUpdates = (updates) => !!updates && Object.keys(updates).length > 0;
+const getResponseItemStatus = (flexResponse) => flexResponse?.data?.payload?.[0]?.status;
+const countProperties = (object) => (object && typeof object === 'object') ? Object.keys(object).length : 0;
 class BaseEntityProcessor {
     constructor(config, dc, mapFileUtil, baseType) {
         this.config = config;
@@ -25,33 +32,37 @@ class BaseEntityProcessor {
     }
     // inbound
     async inbound(event) {
-        const eventType = event.eventType;
-        console.log(`inbound entity: ${eventType}:${event.objectClass}`);
-        switch (eventType) {
-            case 'PERSIST':
-                return await this.handleIncomingUpsert(event);
-            case 'DELETE':
-                return await this.handleIncomingDelete(event);
-            default:
-                console.error(UNSUPPORTED_TYPE);
-                return {
-                    status: 500,
-                    data: { UNSUPPORTED_TYPE }
-                };
-        }
+        return (0, telemetry_1.traceSection)('process_inbound_entity', {
+            [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_TYPE]: this.baseType,
+            [telemetry_attributes_1.ATTR_FLEXPLM_EVENT_OBJECT_CLASS]: event?.objectClass,
+            [telemetry_attributes_1.ATTR_FLEXPLM_EVENT_TYPE]: event?.eventType,
+        }, async () => {
+            const eventType = event.eventType;
+            switch (eventType) {
+                case 'PERSIST':
+                    return await this.handleIncomingUpsert(event);
+                case 'DELETE':
+                    return await this.handleIncomingDelete(event);
+                default:
+                    telemetry_1.logger.warn({ flexplm: { direction: 'inbound', event_type: eventType, entity_type: this.baseType } }, 'Unsupported FlexPLM event type');
+                    return {
+                        status: 500,
+                        data: { UNSUPPORTED_TYPE }
+                    };
+            }
+        });
     }
     async handleIncomingUpsert(event) {
         const inboundData = await this.getTransformedData(event);
         const incomingEntityResponse = await this.getIncomingEntity(event, inboundData);
         // This case means there was an early return in the getIncomingEntity method
         if (incomingEntityResponse.earlyReturn) {
-            const statusMsg = this.getInboundStatusMessage({
+            this.recordInboundStatus({
                 status: event_short_message_status_1.EventShortMessageStatus.FAILURE,
                 statusMessage: incomingEntityResponse.earlyReturn.shortStatusMessage || '',
                 objectClass: event.objectClass,
                 federatedId: event.federatedId
             });
-            console.log(statusMsg);
             return incomingEntityResponse.earlyReturn;
         }
         const entity = incomingEntityResponse.entity;
@@ -61,13 +72,12 @@ class BaseEntityProcessor {
                 const status = (createEntityResponse.earlyReturn.shortStatusMessage === event_short_message_status_1.EventShortMessageStatus.NOT_CREATABLE)
                     ? event_short_message_status_1.EventShortMessageStatus.SUCCESS
                     : event_short_message_status_1.EventShortMessageStatus.FAILURE;
-                const statusMsg = this.getInboundStatusMessage({
+                this.recordInboundStatus({
                     status,
                     statusMessage: createEntityResponse.earlyReturn.shortStatusMessage || '',
                     objectClass: event.objectClass,
                     federatedId: event.federatedId
                 });
-                console.log(statusMsg);
                 return createEntityResponse.earlyReturn;
             }
             let createdEntity = await this.createEntity(this.baseType, createEntityResponse.entity);
@@ -75,14 +85,13 @@ class BaseEntityProcessor {
             if (shouldSyncThumbnail) {
                 createdEntity = await new thumbnail_util_1.ThumbnailUtil(this.config).syncThumbnailToVibeIQ({ entityId: createdEntity.id, primaryViewableId: createdEntity.primaryViewableId, event, entityName: this.baseType }) || createdEntity;
             }
-            const statusMsg = this.getInboundStatusMessage({
+            this.recordInboundStatus({
                 status: event_short_message_status_1.EventShortMessageStatus.SUCCESS,
                 statusMessage: event_short_message_status_1.EventShortMessageStatus.CREATED,
                 objectClass: event.objectClass,
-                entityId: 'id',
+                entityId: createdEntity?.id,
                 federatedId: event.federatedId
             });
-            console.log(statusMsg);
             return createdEntity;
         }
         const diffs = await this.getUpdatesForEntity(entity, inboundData, event.data);
@@ -93,25 +102,23 @@ class BaseEntityProcessor {
         }
         const hasPropertyChanges = Object.getOwnPropertyNames(diffs).length > 0;
         if (!hasPropertyChanges && thumbnailEntity) {
-            const statusMsg = this.getInboundStatusMessage({
+            this.recordInboundStatus({
                 status: event_short_message_status_1.EventShortMessageStatus.SUCCESS,
                 statusMessage: event_short_message_status_1.EventShortMessageStatus.PRIMARY_CONTENT_UPDATED,
                 objectClass: event.objectClass,
                 entityId: entity.id,
                 federatedId: event.federatedId
             });
-            console.log(statusMsg);
             return thumbnailEntity;
         }
         if (!hasPropertyChanges) {
-            const statusMsg = this.getInboundStatusMessage({
+            this.recordInboundStatus({
                 status: event_short_message_status_1.EventShortMessageStatus.SUCCESS,
                 statusMessage: event_short_message_status_1.EventShortMessageStatus.NO_CHANGES,
                 objectClass: event.objectClass,
                 entityId: entity.id,
                 federatedId: event.federatedId
             });
-            console.log(statusMsg);
             const message = 'No Changes to persist for entity: ' + entity.id;
             return {
                 status: 200,
@@ -119,16 +126,16 @@ class BaseEntityProcessor {
             };
         }
         const updatedEntity = await this.updateEntity(this.baseType, entity, diffs);
-        const statusMsg = this.getInboundStatusMessage({
+        this.recordInboundStatus({
             status: event_short_message_status_1.EventShortMessageStatus.SUCCESS,
             statusMessage: event_short_message_status_1.EventShortMessageStatus.UPDATED,
             objectClass: event.objectClass,
             entityId: entity.id,
             federatedId: event.federatedId
         });
-        console.log(statusMsg);
         return updatedEntity;
     }
+    /** @deprecated Use {@link recordInboundStatus}, which logs structured fields and sets span attributes. */
     getInboundStatusMessage(statusObject) {
         return 'BaseEntityProcessor: inbound: status: ' + statusObject.status
             + ', statusMessage: ' + statusObject.statusMessage
@@ -138,6 +145,60 @@ class BaseEntityProcessor {
             + ', federatedId: ' + statusObject.federatedId
             + ', orgSlug: ' + this.orgSlug;
     }
+    /** Records the result of one inbound event: attributes on the active span plus one structured log.
+     * A Failure here is a handled early return, so it is a warning and the span stays OK.
+     */
+    recordInboundStatus(statusObject) {
+        const { status, statusMessage, objectClass, entityId, federatedId } = statusObject;
+        (0, telemetry_utils_1.setActiveSpanAttributes)({
+            [telemetry_attributes_1.ATTR_FLEXPLM_STATUS]: status,
+            [telemetry_attributes_1.ATTR_FLEXPLM_OUTCOME]: statusMessage,
+            [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_TYPE]: this.baseType,
+            [telemetry_attributes_1.ATTR_FLEXPLM_EVENT_OBJECT_CLASS]: objectClass,
+            [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_ID]: entityId,
+            [telemetry_attributes_1.ATTR_FLEXPLM_FEDERATED_ID]: federatedId,
+        });
+        const fields = { flexplm: {
+                direction: 'inbound', status, outcome: statusMessage, entity_type: this.baseType,
+                entity_id: entityId, object_class: objectClass, federated_id: federatedId,
+            } };
+        if (status === event_short_message_status_1.EventShortMessageStatus.FAILURE) {
+            telemetry_1.logger.warn(fields, 'FlexPLM inbound entity not processed: %j', fields.flexplm);
+        }
+        else {
+            telemetry_1.logger.info(fields, 'FlexPLM inbound entity processed: %j', fields.flexplm);
+        }
+    }
+    /** Records the result of sending one entity to FlexPLM: attributes on the active span plus one structured log.
+     * On failure the caller still rethrows; the log keeps the entity context that the action's error log lacks.
+     * A Success whose response item status is not 'OK' is recorded as a Failure: FlexPLM accepted the request
+     * but rejected the item. Nothing is thrown for it, so it is a warning and the span stays OK.
+     */
+    recordOutboundStatus(statusObject) {
+        const { entityId, objectClass, httpStatus, updatedFromResponse, itemStatus, error } = statusObject;
+        const rejected = statusObject.status === event_short_message_status_1.EventShortMessageStatus.SUCCESS && !!itemStatus && itemStatus !== FLEXPLM_ITEM_STATUS_OK;
+        const status = rejected ? event_short_message_status_1.EventShortMessageStatus.FAILURE : statusObject.status;
+        (0, telemetry_utils_1.setActiveSpanAttributes)({
+            [telemetry_attributes_1.ATTR_FLEXPLM_STATUS]: status,
+            [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_ID]: entityId,
+            [telemetry_attributes_1.ATTR_FLEXPLM_EVENT_OBJECT_CLASS]: objectClass,
+            [telemetry_attributes_1.ATTR_FLEXPLM_UPDATED_FROM_RESPONSE]: updatedFromResponse,
+            [telemetry_attributes_1.ATTR_FLEXPLM_RESPONSE_ITEM_STATUS]: itemStatus,
+        });
+        const flexplm = {
+            direction: 'outbound', status, entity_type: this.baseType, entity_id: entityId,
+            object_class: objectClass, http_status: httpStatus, item_status: itemStatus, updated_from_response: updatedFromResponse,
+        };
+        if (rejected) {
+            telemetry_1.logger.warn({ flexplm }, 'FlexPLM outbound entity rejected: %j', flexplm);
+        }
+        else if (status === event_short_message_status_1.EventShortMessageStatus.FAILURE) {
+            telemetry_1.logger.error({ error, flexplm }, 'FlexPLM outbound entity failed: %j', flexplm);
+        }
+        else {
+            telemetry_1.logger.info({ flexplm }, 'FlexPLM outbound entity sent: %j', flexplm);
+        }
+    }
     /** Looks up an identity record from the identity service based on the passed in criteria.
      * If no identity record is found, returns undefined. If multiple are found, throws an error.
      *
@@ -178,25 +239,29 @@ class BaseEntityProcessor {
      * @throws error if multiple identity entities are found, or if required parameters are missing
      */
     async getEntityUsingIdentityService(params) {
-        const identityEntity = await this.getIdentityEntity(params);
-        if (!identityEntity) {
-            return undefined;
-        }
-        const entityReference = identityEntity.entityReference;
-        if (typeof entityReference !== 'string' || !entityReference.includes(':')) {
-            throw new Error(`Invalid identity entityReference: ${String(entityReference)}`);
-        }
-        const firstColonIndex = entityReference.indexOf(':');
-        if (firstColonIndex === 0 || firstColonIndex === entityReference.length - 1) {
-            throw new Error('Invalid identity entityReference: ' + entityReference);
-        }
-        const entityName = entityReference.slice(0, firstColonIndex);
-        const id = entityReference.slice(firstColonIndex + 1);
-        const entity = await this.entities.get({
-            entityName,
-            id
+        return (0, telemetry_1.traceSection)('get_entity_by_identity', { [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_TYPE]: this.baseType }, async (span) => {
+            const identityEntity = await this.getIdentityEntity(params);
+            if (!identityEntity) {
+                span.setAttribute(telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_FOUND, false);
+                return undefined;
+            }
+            const entityReference = identityEntity.entityReference;
+            if (typeof entityReference !== 'string' || !entityReference.includes(':')) {
+                throw new Error(`Invalid identity entityReference: ${String(entityReference)}`);
+            }
+            const firstColonIndex = entityReference.indexOf(':');
+            if (firstColonIndex === 0 || firstColonIndex === entityReference.length - 1) {
+                throw new Error('Invalid identity entityReference: ' + entityReference);
+            }
+            const entityName = entityReference.slice(0, firstColonIndex);
+            const id = entityReference.slice(firstColonIndex + 1);
+            const entity = await this.entities.get({
+                entityName,
+                id
+            });
+            span.setAttribute(telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_FOUND, !!entity);
+            return entity;
         });
-        return entity;
     }
     /**This will query for the entity, and handle post-processing
      * of any critieria that is defined at the sub-type level.
@@ -216,9 +281,12 @@ class BaseEntityProcessor {
         if (!propertyCriteria || Object.getOwnPropertyNames(propertyCriteria).length == 0) {
             throw new Error('propertyCriteria must be defined and have at least one property');
         }
-        const { rootTypeCriteria, subTypeCriteria } = await this.getCriteriaForEntity(entityType, entityTypePath, propertyCriteria);
-        const returnedEntities = await this.dc.getAllObjectReferences(entityType, rootTypeCriteria, subTypeCriteria);
-        return returnedEntities;
+        return (0, telemetry_1.traceSection)('query_entities_by_criteria', { [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_TYPE]: entityType }, async (span) => {
+            const { rootTypeCriteria, subTypeCriteria } = await this.getCriteriaForEntity(entityType, entityTypePath, propertyCriteria);
+            const returnedEntities = await this.dc.getAllObjectReferences(entityType, rootTypeCriteria, subTypeCriteria);
+            span.setAttribute(telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_RESULT_COUNT, Array.isArray(returnedEntities) ? returnedEntities.length : 0);
+            return returnedEntities;
+        });
     }
     /** This is to get the criteria for the entity that is being processed.
      * This is to be overridden for item & project-item because of the need for
@@ -268,7 +336,11 @@ class BaseEntityProcessor {
         return rootTypePropertyKeys;
     }
     async handleIncomingDelete(event) {
-        console.warn('delete is not configured', event);
+        // Only identifying fields are logged, not the event data.
+        telemetry_1.logger.warn({ flexplm: {
+                direction: 'inbound', event_type: event?.eventType, entity_type: this.baseType,
+                object_class: event?.objectClass, federated_id: event?.federatedId,
+            } }, 'FlexPLM delete is not configured');
     }
     async getTransformedData(event) {
         let inboundData = event.data;
@@ -327,7 +399,15 @@ class BaseEntityProcessor {
             object: changes,
         };
         console.log("createEntity: " + JSON.stringify(options));
-        return await new sdk_1.Entities().create(options);
+        return (0, telemetry_1.traceSection)('create_vibeiq_entity', {
+            [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_TYPE]: entityName,
+            [telemetry_attributes_1.ATTR_FLEXPLM_CHANGED_PROPERTY_COUNT]: countProperties(changes),
+        }, async (span) => {
+            const created = await new sdk_1.Entities().create(options);
+            if (created?.id)
+                span.setAttribute(telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_ID, created.id);
+            return created;
+        });
     }
     async updateEntity(entityName, entity, diffs) {
         const options = {
@@ -336,68 +416,78 @@ class BaseEntityProcessor {
             object: diffs
         };
         console.log('updateEntity: ' + JSON.stringify(options));
-        return await new sdk_1.Entities().update(options);
+        return (0, telemetry_1.traceSection)('update_vibeiq_entity', {
+            [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_TYPE]: entityName,
+            [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_ID]: entity?.['id'],
+            [telemetry_attributes_1.ATTR_FLEXPLM_CHANGED_PROPERTY_COUNT]: countProperties(diffs),
+        }, () => new sdk_1.Entities().update(options));
     }
     // outbound
     async outbound(event) {
-        const entityType = event.entityType;
-        const eventType = event.eventType;
-        const entityId = event.id;
-        console.log(`outbound: ${entityType}:${entityId}`);
-        switch (eventType) {
-            case 'update':
-            case 'create':
-                return await this.handleOutgoingUpsert(entityType, event);
-            case 'delete':
-                return await this.handleOutgoingDelete(entityType, event);
-            case 'sendUpsertToFlexPLM':
-                return await this.sendUpsertToFlexPLM(event);
-            default:
-                console.log(UNSUPPORTED_TYPE);
+        return (0, telemetry_1.traceSection)('process_outbound_entity', {
+            [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_TYPE]: this.baseType,
+            [telemetry_attributes_1.ATTR_FLEXPLM_EVENT_TYPE]: event?.eventType,
+        }, async () => {
+            const entityType = event.entityType;
+            const eventType = event.eventType;
+            (0, telemetry_utils_1.setActiveSpanAttributes)({ [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_ID]: event.id });
+            switch (eventType) {
+                case 'update':
+                case 'create':
+                    return await this.handleOutgoingUpsert(entityType, event);
+                case 'delete':
+                    return await this.handleOutgoingDelete(entityType, event);
+                case 'sendUpsertToFlexPLM':
+                    return await this.sendUpsertToFlexPLM(event);
+                default:
+                    telemetry_1.logger.warn({ flexplm: { direction: 'outbound', event_type: eventType, entity_type: this.baseType, entity_id: event.id } }, 'Unsupported FlexPLM event type');
+                    return {
+                        status: 500,
+                        data: { UNSUPPORTED_TYPE }
+                    };
+            }
+        });
+    }
+    async handleOutgoingUpsert(entityType, event) {
+        return (0, telemetry_1.traceSection)('upsert_entity_in_flexplm', { [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_TYPE]: this.baseType }, async () => {
+            const objectClass = await type_conversion_utils_1.TypeConversionUtils.getObjectClass(this.transformMapFile, this.mapFileUtil, event.newData);
+            if (!objectClass) {
+                const message = 'ObjectClass must have a value.';
+                telemetry_1.logger.warn({ flexplm: { direction: 'outbound', entity_type: this.baseType, entity_id: event.id } }, message);
                 return {
                     status: 500,
-                    data: { UNSUPPORTED_TYPE }
+                    data: { message }
                 };
-        }
-    }
-    async handleOutgoingUpsert(entityType, event) {
-        const objectClass = await type_conversion_utils_1.TypeConversionUtils.getObjectClass(this.transformMapFile, this.mapFileUtil, event.newData);
-        if (!objectClass) {
-            const message = 'ObjectClass must have a value.';
-            console.log(message);
-            return {
-                status: 500,
-                data: { message }
-            };
-        }
-        try {
-            const payload = await this.getOutgoingUpsertPayload(entityType, event);
-            const flexResponse = await new flexplm_connect_1.FlexPLMConnect(this.config).sendToFlexPLM(payload);
-            const outboundEntityUpdates = await this.getOutboundEntityUpdates(event, flexResponse);
-            if (outboundEntityUpdates) {
-                flexResponse['outboundEntityUpdates'] = outboundEntityUpdates;
             }
-            const statusMsg = 'BaseEntityProcessor: outbound: status: ' + event_short_message_status_1.EventShortMessageStatus.SUCCESS
-                + ', statusMessage: ' + flexResponse.status
-                + ', entityType: ' + this.baseType
-                + ', entityId: ' + event.id
-                + ', objectClass: ' + payload.objectClass
-                + ', updateFromResponse: ' + ((outboundEntityUpdates && Object.keys(outboundEntityUpdates).length > 0) ? 'true' : 'false')
-                + ', orgSlug: ' + this.orgSlug;
-            console.log(statusMsg);
-            return flexResponse;
-        }
-        catch (e) {
-            const statusMsg = 'BaseEntityProcessor: outbound: status: ' + event_short_message_status_1.EventShortMessageStatus.FAILURE
-                + ', statusMessage: ' + e.httpResponseStatus
-                + ', entityType: ' + this.baseType
-                + ', entityId: ' + event.id
-                + ', objectClass: ' + objectClass
-                + ', updateFromResponse: ' + 'false'
-                + ', orgSlug: ' + this.orgSlug;
-            console.log(statusMsg);
-            throw e;
-        }
+            try {
+                const payload = await this.getOutgoingUpsertPayload(entityType, event);
+                const flexResponse = await new flexplm_connect_1.FlexPLMConnect(this.config).sendToFlexPLM(payload);
+                const outboundEntityUpdates = await this.getOutboundEntityUpdates(event, flexResponse);
+                if (outboundEntityUpdates) {
+                    flexResponse['outboundEntityUpdates'] = outboundEntityUpdates;
+                }
+                this.recordOutboundStatus({
+                    status: event_short_message_status_1.EventShortMessageStatus.SUCCESS,
+                    entityId: event.id,
+                    objectClass: payload.objectClass,
+                    httpStatus: flexResponse.status,
+                    updatedFromResponse: hasUpdates(outboundEntityUpdates),
+                    itemStatus: getResponseItemStatus(flexResponse),
+                });
+                return flexResponse;
+            }
+            catch (e) {
+                this.recordOutboundStatus({
+                    status: event_short_message_status_1.EventShortMessageStatus.FAILURE,
+                    entityId: event.id,
+                    objectClass,
+                    httpStatus: e.httpResponseStatus,
+                    updatedFromResponse: false,
+                    error: e,
+                });
+                throw e;
+            }
+        });
     }
     async getOutboundEntityUpdates(event, flexResponse) {
         const payload = flexResponse?.data?.payload;
@@ -413,7 +503,10 @@ class BaseEntityProcessor {
         return outboundEntityUpdates;
     }
     async handleOutgoingDelete(entityType, event) {
-        console.warn('delete is not configured', entityType, event.oldData);
+        // Only identifying fields are logged, not oldData.
+        telemetry_1.logger.warn({ flexplm: {
+                direction: 'outbound', event_type: event?.eventType, entity_type: entityType, entity_id: event?.id,
+            } }, 'FlexPLM delete is not configured');
     }
     /** Create a new event-workflow-request to rerun sending the entity to FlexPLM
      * The event must contain any information needed to ensure it is put in the correct queue for the entity
@@ -440,44 +533,46 @@ class BaseEntityProcessor {
      * @returns results of sending the entity to FlexPLM
      */
     async sendUpsertToFlexPLM(event) {
-        const payload = await this.getEntityCurrentStateUpsertPayload(event);
-        if (!payload) {
-            const message = 'No payload to send to FlexPLM';
-            console.log(message);
-            return {
-                status: 500,
-                data: { message }
-            };
-        }
-        ;
-        let objectClass = payload.objectClass;
-        try {
-            const flexResponse = await new flexplm_connect_1.FlexPLMConnect(this.config).sendToFlexPLM(payload);
-            const outboundEntityUpdates = await this.getOutboundEntityUpdates(event, flexResponse);
-            if (outboundEntityUpdates) {
-                flexResponse['outboundEntityUpdates'] = outboundEntityUpdates;
+        return (0, telemetry_1.traceSection)('send_current_entity_to_flexplm', { [telemetry_attributes_1.ATTR_FLEXPLM_ENTITY_TYPE]: this.baseType }, async () => {
+            const payload = await this.getEntityCurrentStateUpsertPayload(event);
+            if (!payload) {
+                const message = 'No payload to send to FlexPLM';
+                telemetry_1.logger.warn({ flexplm: { direction: 'outbound', entity_type: this.baseType, entity_id: event.id } }, message);
+                return {
+                    status: 500,
+                    data: { message }
+                };
             }
-            const statusMsg = 'BaseEntityProcessor: outbound: status: ' + event_short_message_status_1.EventShortMessageStatus.SUCCESS
-                + ', statusMessage: ' + flexResponse.status
-                + ', entityType: ' + this.baseType
-                + ', entityId: ' + event.id
-                + ', objectClass: ' + objectClass
-                + ', updateFromResponse: ' + ((outboundEntityUpdates && Object.keys(outboundEntityUpdates).length > 0) ? 'true' : 'false')
-                + ', orgSlug: ' + this.orgSlug;
-            console.log(statusMsg);
-            return flexResponse;
-        }
-        catch (e) {
-            const statusMsg = 'BaseEntityProcessor: outbound: status: ' + event_short_message_status_1.EventShortMessageStatus.FAILURE
-                + ', statusMessage: ' + e.httpResponseStatus
-                + ', entityType: ' + this.baseType
-                + ', entityId: ' + event.id
-                + ', objectClass: ' + objectClass
-                + ', updateFromResponse: ' + 'false'
-                + ', orgSlug: ' + this.orgSlug;
-            console.log(statusMsg);
-            throw e;
-        }
+            ;
+            let objectClass = payload.objectClass;
+            try {
+                const flexResponse = await new flexplm_connect_1.FlexPLMConnect(this.config).sendToFlexPLM(payload);
+                const outboundEntityUpdates = await this.getOutboundEntityUpdates(event, flexResponse);
+                if (outboundEntityUpdates) {
+                    flexResponse['outboundEntityUpdates'] = outboundEntityUpdates;
+                }
+                this.recordOutboundStatus({
+                    status: event_short_message_status_1.EventShortMessageStatus.SUCCESS,
+                    entityId: event.id,
+                    objectClass,
+                    httpStatus: flexResponse.status,
+                    updatedFromResponse: hasUpdates(outboundEntityUpdates),
+                    itemStatus: getResponseItemStatus(flexResponse),
+                });
+                return flexResponse;
+            }
+            catch (e) {
+                this.recordOutboundStatus({
+                    status: event_short_message_status_1.EventShortMessageStatus.FAILURE,
+                    entityId: event.id,
+                    objectClass,
+                    httpStatus: e.httpResponseStatus,
+                    updatedFromResponse: false,
+                    error: e,
+                });
+                throw e;
+            }
+        });
     }
     /** Generates the payload to send to FlexPLM, based on the current state of the entity.
      * The current state of the entity are used as the newData and oldData; which is passed