elasticio-sailor-nodejs 3.0.0-sailor-proxy-dev9 → 3.0.0-sailor-proxy-dev11

package/{.eslintrc → .eslintrc.json}

@@ -20,6 +20,7 @@
         "BigInt": true
     },
     "rules": {
+        "no-undef": "error",
         "array-bracket-spacing": ["warn", "never"],
         "no-prototype-builtins": "warn",
         "object-curly-newline": ["warn", { "multiline": true, "consistent": true }],

package/lib/encryptor.js

@@ -84,6 +84,7 @@ class Encryptor {
      */
     _encryptToBuffer(message) {
         if (!this._encryptionKey) {
+            log.warn('Encryption key is not set, message will be stored in plain text');
             return Buffer.from(message);
         }
         const cipher = this.createCipher();

package/lib/proxy-client.js

@@ -16,10 +16,10 @@ const {
     NGHTTP2_NO_ERROR
 } = http2.constants;
 
+const MESSAGE_METADATA_QUERY_PARAM = 'message-metadata';
 const HEADER_ROUTING_KEY = 'x-eio-routing-key';
 const AMQP_HEADER_META_PREFIX = 'x-eio-meta-';
 const OBJECT_ID_HEADER = 'x-ipaas-object-storage-id';
-const PROXY_FORWARD_HEADER_PREFIX = 'x-sailor-proxy-forward-';
 const MESSAGE_PROCESSING_STATUS = {
     SUCCESS: 'success',
     ERROR: 'error'
@@ -315,9 +315,7 @@ class ProxyClient {
             return body;
         }
 
-        logger.info('Object id header found, message is lightweight.', { objectId });
-
-        logger.info('Going to fetch message body.', { objectId });
+        logger.info('Object id header found, message is lightweight. Going to fetch message body.', { objectId });
 
         await this._proxyRequestWithRetries('Fetch message body', () => new Promise((resolve, reject) => {
             const getObjectStream = this.clientSession.request({
@@ -456,10 +454,10 @@ class ProxyClient {
                         });
                     });
 
-                    const proxyHeaders = this._extractProxyHeaders(headers);
-                    const message = this._decodeMessage(body, headers);
-                    log.debug({ proxyHeaders, message }, 'Processing received message');
-                    await messageHandler(proxyHeaders, message);
+                    const messageMetadata = this._extractMessageMetadata(headers);
+                    const message = this._decodeMessage(body, messageMetadata);
+                    log.debug({ messageMetadata, message }, 'Processing received message');
+                    await messageHandler(messageMetadata, message);
                 }));
             } catch (err) {
                 if (this.closed) {
@@ -497,7 +495,7 @@ class ProxyClient {
         this.listeningForMessages = false;
     }
 
-    _prepareData(data, headers, type) {
+    _prepareData(data, metadata, type) {
         let protocolVersion;
         if (type === 'data') {
             protocolVersion = this.settings.PROTOCOL_VERSION;
@@ -508,10 +506,16 @@ class ProxyClient {
         if (protocolVersion) {
             preparedData = this.encryptMessageContent(data, protocolVersion);
         }
-        const proxyHeaders = this._createProxyHeaders({ ...headers, protocolVersion });
+        const preparedMetadata = {
+            ...metadata,
+            messageId: metadata.messageId || uuid.v4()
+        };
         return {
             preparedData,
-            proxyHeaders
+            preparedMetadata: _.omitBy(
+                preparedMetadata,
+                (value, key) => key.toLowerCase().startsWith(AMQP_HEADER_META_PREFIX)
+            )
         };
     }
 
@@ -519,19 +523,22 @@ class ProxyClient {
         incomingMessageId,
         type,
         data,
-        headers
+        metadata
     }) {
         await this._ensureConnection();
 
         const throttledSend = this.throttles[type];
         if (throttledSend) {
-            log.debug({ incomingMessageId, type, headers }, 'Applying rate limiting for message send');
+            log.debug({ incomingMessageId, type, metadata }, 'Applying rate limiting for message send');
             await throttledSend();
         }
 
-        log.debug({ incomingMessageId, type, headers }, 'Sending message to proxy');
+        const messageHeaders = _.mapKeys(data.headers || {}, (value, key) => key.toLowerCase());
+        const customRoutingKey = messageHeaders[HEADER_ROUTING_KEY];
+
+        log.debug({ incomingMessageId, type, metadata, customRoutingKey }, 'Sending message to proxy');
         log.trace({ data }, 'Message data to send to proxy');
-        const { proxyHeaders, preparedData } = this._prepareData(data, headers, type);
+        const { preparedMetadata, preparedData } = this._prepareData(data, metadata, type);
         if (preparedData.length > this.settings.OUTGOING_MESSAGE_SIZE_LIMIT) {
             const error = new Error(`Outgoing message size ${preparedData.length}` +
                 ` exceeds limit of ${this.settings.OUTGOING_MESSAGE_SIZE_LIMIT}.`);
@@ -539,21 +546,18 @@ class ProxyClient {
             throw error;
         }
 
-        const messageHeaders = _.mapKeys(data.headers || {}, (value, key) => key.toLowerCase());
-        const customRoutingKey = messageHeaders[HEADER_ROUTING_KEY];
         const queryParams = new URLSearchParams({
             incomingMessageId,
             stepId: this.settings.STEP_ID,
             type,
             ...(customRoutingKey ? { customRoutingKey } : {})
         }).toString();
-
         await this._proxyRequestWithRetries('Send message', () => new Promise((resolve, reject) => {
             const postMessageStream = this.clientSession.request({
-                ...proxyHeaders,
                 [HTTP2_HEADER_PATH]: `/message?${queryParams}`,
                 [HTTP2_HEADER_METHOD]: 'POST',
-                [HTTP2_HEADER_AUTHORIZATION]: this.authHeader
+                [HTTP2_HEADER_AUTHORIZATION]: this.authHeader,
+                [MESSAGE_METADATA_QUERY_PARAM]: JSON.stringify(preparedMetadata)
             });
             postMessageStream.write(preparedData);
             postMessageStream.end();
@@ -579,33 +583,35 @@ class ProxyClient {
         }));
     }
 
-    _decodeMessage(originalMessage, headers) {
+    _decodeMessage(originalMessage, metadata) {
         log.trace('Message received');
         let message;
         if (this.settings.INPUT_FORMAT === 'error') {
-            message = this._decodeErrorMessage(originalMessage, headers);
+            message = this._decodeErrorMessage(originalMessage);
         } else {
-            message = this._decodeDefaultMessage(originalMessage, headers);
+            message = this._decodeDefaultMessage(originalMessage, metadata);
         }
         message.headers = message.headers || {};
-        if (headers.replyTo) {
-            message.headers.reply_to = headers.replyTo;
+        if (metadata.reply_to) {
+            message.headers.reply_to = metadata.reply_to;
         }
         return message;
     }
 
-    _decodeDefaultMessage(originalMessage, headers) {
-        const protocolVersion = Number(headers.protocolVersion || 1);
+    _decodeDefaultMessage(originalMessage, metadata) {
+        log.debug({ metadata }, 'Decoding default message format');
+        const protocolVersion = Number(metadata.protocolVersion || 1);
+        log.debug({ protocolVersion }, 'Decoding message with protocol version');
         return this._encryptor.decryptMessageContent(
             originalMessage,
             protocolVersion < 2 ? 'base64' : undefined
         );
     }
 
-    _decodeErrorMessage(originalMessage, headers) {
+    _decodeErrorMessage(originalMessage) {
         const errorBody = JSON.parse(originalMessage.toString());
         // NOTICE both error and errorInput are transferred as base64 encoded.
-        // this does not depend on protocolVersion header of message (see _decodeDefaultMessage)
+        // this does not depend on protocolVersion of message (see _decodeDefaultMessage)
         // this should be fixed in future, but it's OK at this moment
         if (errorBody.error) {
             errorBody.error = this._encryptor.decryptMessageContent(Buffer.from(errorBody.error), 'base64');
@@ -613,19 +619,16 @@ class ProxyClient {
         if (errorBody.errorInput) {
             errorBody.errorInput = this._encryptor.decryptMessageContent(errorBody.errorInput, 'base64');
         }
-        return {
-            body: errorBody,
-            headers
-        };
+        return errorBody;
     }
 
-    async finishProcessing(incomingHeaders, status) {
+    async finishProcessing(metadata, status) {
         await this._ensureConnection();
 
         if (Object.values(MESSAGE_PROCESSING_STATUS).indexOf(status) === -1) {
             throw new Error(`Invalid message processing status: ${status}`);
         }
-        const incomingMessageId = incomingHeaders.messageId;
+        const incomingMessageId = metadata.messageId;
         log.debug({ incomingMessageId, status }, 'Finishing processing of message');
         const queryParams = new URLSearchParams({
             incomingMessageId,
@@ -661,6 +664,7 @@ class ProxyClient {
     }
 
     encryptMessageContent(body, protocolVersion = 1) {
+        log.debug({ protocolVersion }, 'Encrypting message content with protocol version');
         return this._encryptor.encryptMessageContent(
             body,
             protocolVersion < 2
@@ -669,7 +673,7 @@ class ProxyClient {
         );
     }
 
-    async sendError(err, headers, originalMessage, incomingHeaders) {
+    async sendError(err, outgoingMetadata, originalMessage, metadata) {
         await this._ensureConnection();
 
         const encryptedError = this._encryptor.encryptMessageContent({
@@ -682,94 +686,94 @@ class ProxyClient {
             error: encryptedError
         };
         if (originalMessage) {
-            const protocolVersion = Number(incomingHeaders.protocolVersion || 1);
+            const protocolVersion = Number(metadata.protocolVersion || 1);
             if (protocolVersion >= 2) {
                 payload.errorInput = this._encryptor.encryptMessageContent(
                     originalMessage,
                     'base64'
                 ).toString();
             } else {
+                // TODO: encrypt errorInput
                 payload.errorInput = originalMessage;
             }
         }
         const errorPayload = JSON.stringify(payload);
 
         const result = await this.sendMessage({
-            incomingMessageId: incomingHeaders ? incomingHeaders.messageId : undefined,
+            incomingMessageId: metadata ? metadata.messageId : undefined,
             type: 'error',
             data: errorPayload,
-            headers
+            metadata: outgoingMetadata
         });
 
         return result;
     }
 
-    async sendRebound(reboundError, incomingHeaders, outgoingHeaders) {
+    async sendRebound(reboundError, metadata, outgoingMetadata) {
         await this._ensureConnection();
 
-        outgoingHeaders.end = new Date().getTime();
-        outgoingHeaders.reboundReason = reboundError.message;
+        outgoingMetadata.end = new Date().getTime();
+        outgoingMetadata.reboundReason = reboundError.message;
         return this.sendMessage({
             type: 'rebound',
-            headers: outgoingHeaders,
-            incomingMessageId: incomingHeaders ? incomingHeaders.messageId : undefined,
+            metadata: outgoingMetadata,
+            incomingMessageId: metadata ? metadata.messageId : undefined,
             data: reboundError
         });
     }
 
-    async sendSnapshot(data, headers) {
+    async sendSnapshot(data, metadata) {
         await this._ensureConnection();
 
         const payload = JSON.stringify(data);
-        const properties = this._createProxyHeaders(headers);
         return this.sendMessage({
             type: 'snapshot',
             data: payload,
-            headers: properties
+            metadata
         });
     }
 
-    _createProxyHeaders(headers) {
-        headers.messageId = headers.messageId || uuid.v4();
-        return Object.entries(headers || {}).reduce((acc, [key, value]) => {
-            acc[`${PROXY_FORWARD_HEADER_PREFIX}${_.kebabCase(key)}`] = value;
-            return acc;
-        }, {});
-    }
+    _extractMessageMetadata(headers) {
+        log.trace({ headers }, 'Extracting message metadata');
+        const messageMetadataQuery = headers[MESSAGE_METADATA_QUERY_PARAM];
+        if (!messageMetadataQuery) {
+            log.error({ headers }, 'Missing metadata in message stream response');
+            throw new Error('Missing metadata in message stream response');
+        }
 
-    _extractProxyHeaders(proxyHeaders) {
-        log.trace({ proxyHeaders }, 'Extracting proxy headers');
-        const headers = Object.entries(proxyHeaders || {}).reduce((acc, [key, value]) => {
-            if (key.startsWith(PROXY_FORWARD_HEADER_PREFIX)) {
-                const originalKey = key.substring(PROXY_FORWARD_HEADER_PREFIX.length);
-                acc[_.camelCase(originalKey)] = value;
-            }
-            return acc;
-        }, {});
+        let parsedMessageMetadata;
+        try {
+            parsedMessageMetadata = JSON.parse(messageMetadataQuery);
+        } catch (e) {
+            log.error({ messageMetadataQuery }, 'Failed to parse metadata JSON');
+            throw new Error('Failed to parse metadata JSON');
+        }
+        log.debug({ parsedMessageMetadata }, 'Parsed metadata from query parameter');
 
-        const metaHeaderNames = Object.keys(headers)
+        // Get meta headers
+        const metaHeaderNames = Object.keys(parsedMessageMetadata)
             .filter(key => key.toLowerCase().startsWith(AMQP_HEADER_META_PREFIX));
 
-        const metaHeaders = _.pick(headers, metaHeaderNames);
+        const metaHeaders = _.pick(parsedMessageMetadata, metaHeaderNames);
         const metaHeadersLowerCased = _.mapKeys(metaHeaders, (value, key) => key.toLowerCase());
 
         const result = {
-            stepId: headers.stepId,
+            stepId: parsedMessageMetadata.stepId,
             ...metaHeadersLowerCased,
-            threadId: headers.threadId || metaHeadersLowerCased['x-eio-meta-trace-id'],
-            messageId: headers.messageId,
-            parentMessageId: headers.parentMessageId,
-            protocolVersion: headers.protocolVersion
+            threadId: parsedMessageMetadata.threadId || metaHeaders['x-eio-meta-trace-id'],
+            messageId: parsedMessageMetadata.messageId,
+            parentMessageId: parsedMessageMetadata.parentMessageId,
+            protocolVersion: parsedMessageMetadata.protocolVersion
         };
         if (!result.threadId) {
             const threadId = uuid.v4();
             log.debug({ threadId }, 'Initiate new thread as it is not started ATM');
             result.threadId = threadId;
         }
-        if (headers.replyTo) {
-            result.replyTo = headers.replyTo;
+        if (parsedMessageMetadata.reply_to) {
+            result.reply_to = parsedMessageMetadata.reply_to;
         }
-        log.debug({ result }, 'Extracted proxy headers');
+        log.debug({ result }, 'Extracted message metadata');
         return result;
     }
 }

package/lib/sailor.js

@@ -15,7 +15,7 @@ function convertSettingsToSnakeCase(settings) {
     return _.mapKeys(settings, (value, key) => _.snakeCase(key));
 }
 
-function getAdditionalHeadersFromSettings(settings) {
+function getAdditionalMetadataFromSettings(settings) {
     return convertSettingsToSnakeCase(settings.additionalVars);
 }
 
@@ -83,7 +83,7 @@ class Sailor {
     }
 
     reportError(err) {
-        const headers = Object.assign({}, getAdditionalHeadersFromSettings(this.settings), {
+        const metadata = Object.assign({}, getAdditionalMetadataFromSettings(this.settings), {
             execId: this.settings.EXEC_ID,
             taskId: this.settings.FLOW_ID,
             workspaceId: this.settings.WORKSPACE_ID,
@@ -93,7 +93,7 @@ class Sailor {
             compId: this.settings.COMP_ID,
             function: this.settings.FUNCTION
         });
-        return this.proxyClient.sendError(err, headers);
+        return this.proxyClient.sendError(err, metadata);
     }
 
     startup() {
@@ -166,9 +166,9 @@ class Sailor {
         return this.proxyClient.listenForMessages(handler);
     }
 
-    async processMessageAndMaybeShutdownCallback(headers, body) {
+    async processMessageAndMaybeShutdownCallback(metadata, body) {
         try {
-            await this.processMessage(headers, body);
+            await this.processMessage(metadata, body);
         } catch (e) {
             log.error(e, 'Something very bad happened during message processing');
         } finally {
@@ -207,8 +207,8 @@ class Sailor {
         return new Promise(resolve => this.shutdownCallback = resolve);
     }
 
-    async runExec(module, payload, incomingMessageHeaders, outgoingMessageHeaders, stepData, timeStart, logger) {
-        log.debug({ incomingMessageHeaders }, 'runExec started');
+    async runExec(module, payload, metadata, outgoingMetadata, stepData, timeStart, logger) {
+        log.debug({ metadata }, 'runExec started');
         const origPassthrough = _.cloneDeep(payload.passthrough) || {};
         const settings = this.settings;
         const cfg = _.cloneDeep(stepData.config) || {};
@@ -220,7 +220,7 @@ class Sailor {
             let endWasEmitted;
 
             const taskExec = new TaskExec({
-                loggerOptions: _.pick(incomingMessageHeaders, ['threadId', 'messageId', 'parentMessageId']),
+                loggerOptions: _.pick(metadata, ['threadId', 'messageId', 'parentMessageId']),
                 variables: stepData.variables,
                 services: {
                     apiClient: this.apiClient,
@@ -241,19 +241,19 @@ class Sailor {
             taskExec.process(module, payload, cfg, snapshot);
 
             async function onData(data) {
-                const headers = _.clone(outgoingMessageHeaders);
-                headers.messageId = data.id || headers.messageId;
+                const metadataToSend = _.clone(outgoingMetadata);
+                metadataToSend.messageId = data.id || metadataToSend.messageId;
                 logger.trace({
                     messagesCount: that.messagesCount,
                     messageProcessingTime: Date.now() - timeStart
                 }, 'processMessage emit data');
 
-                headers.end = new Date().getTime();
+                metadataToSend.end = new Date().getTime();
 
                 if (stepData.is_passthrough === true) {
                     data.passthrough = { ...origPassthrough };
                     if (settings.NO_SELF_PASSTRHOUGH) {
-                        const { stepId } = incomingMessageHeaders;
+                        const { stepId } = metadata;
                         if (stepId) {
                             data.passthrough = Object.assign({}, origPassthrough, {
                                 [stepId]: Object.assign({}, _.omit(payload, 'passthrough'))
@@ -357,9 +357,9 @@ class Sailor {
 
                 try {
                     await that.proxyClient.sendMessage({
-                        incomingMessageId: incomingMessageHeaders.messageId,
+                        incomingMessageId: metadata.messageId,
                         data,
-                        headers,
+                        metadata: metadataToSend,
                         type: 'data'
                     });
                     log.trace('Outgoing message sent');
@@ -369,21 +369,21 @@ class Sailor {
             }
 
             async function onHttpReply(reply) {
-                const headers = _.clone(outgoingMessageHeaders);
+                const metadataToSend = _.clone(outgoingMetadata);
                 logger.trace({
                     messageProcessingTime: Date.now() - timeStart
                 }, 'processMessage emit HttpReply');
 
                 return that.proxyClient.sendMessage({
-                    incomingMessageId: incomingMessageHeaders.messageId,
+                    incomingMessageId: metadata.messageId,
                     data: reply,
-                    headers,
+                    metadata: metadataToSend,
                     type: 'http-reply'
                 });
             }
 
             async function onError(err) {
-                const headers = _.clone(outgoingMessageHeaders);
+                const metadataToSend = _.clone(outgoingMetadata);
                 err = formatError(err);
                 taskExec.errorCount++;
                 logger.trace({
@@ -391,38 +391,38 @@ class Sailor {
                     messagesCount: that.messagesCount,
                     messageProcessingTime: Date.now() - timeStart
                 }, 'processMessage emit error');
-                headers.end = new Date().getTime();
-                return that.proxyClient.sendError(err, headers, payload, incomingMessageHeaders);
+                metadataToSend.end = new Date().getTime();
+                return that.proxyClient.sendError(err, metadataToSend, payload, metadata);
             }
 
             async function onRebound(err) {
-                const outgoingHeaders = _.clone(outgoingMessageHeaders);
+                const metadataToSend = _.clone(outgoingMetadata);
                 err = formatError(err);
                 logger.trace({
                     err,
                     messagesCount: that.messagesCount,
                     messageProcessingTime: Date.now() - timeStart
                 }, 'processMessage emit rebound');
-                return that.proxyClient.sendRebound(err, incomingMessageHeaders, outgoingHeaders);
+                return that.proxyClient.sendRebound(err, metadata, metadataToSend);
             }
 
             async function onSnapshot(data) {
-                const headers = _.clone(outgoingMessageHeaders);
-                headers.snapshotEvent = 'snapshot';
+                const metadataToSend = _.clone(outgoingMetadata);
+                metadataToSend.snapshotEvent = 'snapshot';
                 that.snapshot = data; // replacing `local` snapshot
-                return that.proxyClient.sendSnapshot(data, headers);
+                return that.proxyClient.sendSnapshot(data, metadataToSend);
             }
 
             async function onUpdateSnapshot(data) {
-                const headers = _.clone(outgoingMessageHeaders);
-                headers.snapshotEvent = 'updateSnapshot';
+                const metadataToSend = _.clone(outgoingMetadata);
+                metadataToSend.snapshotEvent = 'updateSnapshot';
 
                 if (_.isPlainObject(data)) {
                     if (data.$set) {
                         return log.warn('ERROR: $set is not supported any more in `updateSnapshot` event');
                     }
                     _.extend(that.snapshot, data); // updating `local` snapshot
-                    return that.proxyClient.sendSnapshot(data, headers);
+                    return that.proxyClient.sendSnapshot(data, metadataToSend);
                 } else {
                     log.error('You should pass an object to the `updateSnapshot` event');
                 }
@@ -435,9 +435,9 @@ class Sailor {
 
                 try {
                     await that.apiClient.accounts.update(cfg._account, { keys: keys });
-                    logger.debug({ messageId: incomingMessageHeaders.messageId }, 'Successfully updated keys');
+                    logger.debug({ messageId: metadata.messageId }, 'Successfully updated keys');
                 } catch (error) {
-                    logger.debug({ messageId: incomingMessageHeaders.messageId }, 'Failed to update keys');
+                    logger.debug({ messageId: metadata.messageId }, 'Failed to update keys');
                     await onError(error);
                 }
             }
@@ -455,7 +455,7 @@ class Sailor {
                 endWasEmitted = true;
 
                 await that.proxyClient.finishProcessing(
-                    incomingMessageHeaders,
+                    metadata,
                     taskExec.errorCount > 0
                         ? MESSAGE_PROCESSING_STATUS.ERROR
                         : MESSAGE_PROCESSING_STATUS.SUCCESS
@@ -487,7 +487,7 @@ class Sailor {
         }
     }
 
-    async processMessage(headers, payload) {
+    async processMessage(metadata, payload) {
         // eslint-disable-next-line consistent-this
         const self = this;
         const settings = this.settings;
@@ -497,9 +497,9 @@ class Sailor {
         const timeStart = Date.now();
 
         const logger = log.child({
-            threadId: headers.threadId || 'unknown',
-            messageId: headers.messageId || 'unknown',
-            parentMessageId: headers.parentMessageId || 'unknown'
+            threadId: metadata.threadId || 'unknown',
+            messageId: metadata.messageId || 'unknown',
+            parentMessageId: metadata.parentMessageId || 'unknown'
         });
 
         logger.trace({ messagesCount: this.messagesCount }, 'processMessage received');
@@ -508,11 +508,11 @@ class Sailor {
 
         log.debug('Trigger or action: %s', settings.FUNCTION);
         const outgoingMessageId = uuid.v4();
-        const outgoingMessageHeaders = {
-            ...headers,
-            ...getAdditionalHeadersFromSettings(settings),
-            parentMessageId: headers.messageId,
-            threadId: headers.threadId,
+        const outgoingMetadata = {
+            ...metadata,
+            ...getAdditionalMetadataFromSettings(settings),
+            parentMessageId: metadata.messageId,
+            threadId: metadata.threadId,
             messageId: outgoingMessageId,
             execId: settings.EXEC_ID,
             taskId: settings.FLOW_ID,
@@ -529,9 +529,9 @@ class Sailor {
             module = await this.componentReader.loadTriggerOrAction(settings.FUNCTION);
         } catch (e) {
             log.error(e);
-            outgoingMessageHeaders.end = new Date().getTime();
-            self.proxyClient.sendError(e, outgoingMessageHeaders, payload, headers);
-            self.proxyClient.finishProcessing(headers, MESSAGE_PROCESSING_STATUS.ERROR);
+            outgoingMetadata.end = new Date().getTime();
+            self.proxyClient.sendError(e, outgoingMetadata, payload, metadata);
+            self.proxyClient.finishProcessing(metadata, MESSAGE_PROCESSING_STATUS.ERROR);
             return;
         }
 
@@ -558,14 +558,14 @@ class Sailor {
                 ]);
             } catch (e) {
                 logger.error(e);
-                outgoingMessageHeaders.end = new Date().getTime();
-                self.proxyClient.sendError(e, outgoingMessageHeaders, payload, headers);
-                self.proxyClient.finishProcessing(headers, MESSAGE_PROCESSING_STATUS.ERROR);
+                outgoingMetadata.end = new Date().getTime();
+                self.proxyClient.sendError(e, outgoingMetadata, payload, metadata);
+                self.proxyClient.finishProcessing(metadata, MESSAGE_PROCESSING_STATUS.ERROR);
                 return;
             }
         }
 
-        await this.runExec(module, payload, headers, outgoingMessageHeaders, stepData, timeStart, logger);
+        await this.runExec(module, payload, metadata, outgoingMetadata, stepData, timeStart, logger);
     }
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "elasticio-sailor-nodejs",
     "description": "The official elastic.io library for bootstrapping and executing for Node.js connectors",
-    "version": "3.0.0-sailor-proxy-dev9",
+    "version": "3.0.0-sailor-proxy-dev11",
     "main": "run.js",
     "scripts": {
         "build": "tsc",

package/postpublish.js

@@ -7,6 +7,9 @@ var version = require('./package.json').version;
 if (!version) {
     console.error('Can not determine current version');
     process.exit(0);
+} else if (version.indexOf('dev') > -1) {
+    console.info('Current version is a development version, skipping tag creation');
+    process.exit(0);
 }
 
 var tag = 'v' + version;