ac-support-connector 0.0.1

package/.acsemver.js

@@ -0,0 +1,9 @@
+module.exports = {
+  repository: {
+    url: 'https://github.com/admiralcloud/ac-support-connector'
+  },
+  changelogFile: __dirname + '/CHANGELOG.md',
+  sections: [
+    {name: 'Connector' }
+  ]
+};

package/.eslintrc.js

@@ -0,0 +1,27 @@
+const config = {
+  root: true,
+  'env': {
+    'commonjs': true,
+    'es6': true,
+    'node': true
+  },
+  'extends': 'eslint:recommended',
+  "rules": {
+    "space-before-function-paren": 0,
+    "no-extra-semi": 0,
+    "object-curly-spacing": ["error", "always"],
+    "brace-style": ["error", "stroustrup", { "allowSingleLine": true }],
+    "no-useless-escape": 0,
+    "standard/no-callback-literal": 0,
+    "new-cap": 0
+  },
+  globals: {
+    describe: true,
+    it: true
+  },
+  'parserOptions': {
+    'ecmaVersion': 2021
+},
+}
+
+module.exports = config

package/.github/workflows/node.js.yml

@@ -0,0 +1,36 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [16.x, 18.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+        redis-version: [6]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+
+    - name: Start Redis
+      uses: supercharge/redis-github-action@1.4.0
+      with:
+        redis-version: ${{ matrix.redis-version }}    
+    
+    - run: yarn install
+    - run: yarn run test

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+<a name="0.0.1"></a>
+
+## [0.0.1](https://github.com/admiralcloud/ac-support-connector/compare/..v0.0.1) (2022-12-23 13:54:01)
+
+
+### Bug Fix
+
+* **Connector:** Initial version | MP | [a6ceabb22ef634818911ad41daebcd82e0f8dbfb](https://github.com/admiralcloud/ac-support-connector/commit/a6ceabb22ef634818911ad41daebcd82e0f8dbfb)    
+Initial version

package/Makefile

@@ -0,0 +1,16 @@
+MOCHA_OPTS= --slow 0 -A
+REPORTER = spec
+
+lint-fix:
+	./node_modules/.bin/eslint --fix index.js test/test.js
+
+lint-check:
+	./node_modules/.bin/eslint index.js test/test.js
+
+commit:
+	@node ./node_modules/ac-semantic-release/lib/commit.js
+
+release:
+	@node ./node_modules/ac-semantic-release/lib/release.js
+
+.PHONY: check

package/README.md

@@ -0,0 +1,71 @@
+# AC Support Connector
+This module sends unified support payloads to SQS. A dedicated service (not part of the connector) then processes those SQS messages and delivers the support messages to different channels (e.g. Teams, a helpdesk, etc) 
+
+[![Node.js CI](https://github.com/AdmiralCloud/ac-geoip/actions/workflows/node.js.yml/badge.svg)](https://github.com/AdmiralCloud/ac-support-connector/actions/workflows/node.js.yml)
+
+# Prerequisites
+Create a SQS queue (e.g. supportQueue) and use a policy that allows all (or selected) IAM users from the account to send messages to the queue:
+
+```
+{
+      "Sid": "Statement1",
+      "Effect": "Allow",
+      "Principal": {
+        "AWS": "arn:aws:iam::ACCOUNTID:root"
+      },
+      "Action": "sqs:SendMessage",
+      "Resource": "arn:aws:sqs:eu-central-1:ACCOUNTID:supportQueue"
+    }
+```
+
+# Usage
+```
+// Init during bootstrap
+
+const supportConnector = require('ac-support-connector')
+
+supportConnector.init({
+  accountId: 'AWS AccountId',
+  accessKeyId: 'AWSAK',
+  secretAccessKey: 'AWSSECRET',
+  region: 'AWS REGION',
+  serviceName: 'my-service',
+  instanceId: 'abc123' // optional unique identifier (for the instance the service is running on)
+  sqsQueue: 'mySupportList' // optional SQS queue name, if none set, defaults to 'supportQueue'
+})
+
+// now send logs like this
+
+supportConnector.createMessage({ 
+  subject: 'Operation failed',
+  text: 'The operation ABC failed due to missing parameter',
+  level: 'warn' // optional, if none is set, the level is info
+})
+```
+
+# Parameters
+## Init
+|Parameter|Type|Usage|
+|---|---|---|
+|accessKeyId|string|AWS accessKeyId with permission to send to SQS queue
+|secretAccessKey|string|AWS secretAccessKey
+|region|string|AWS region
+|serviceName|string|Name of the service sending the support ticket
+|instanceId|string OPTIONAL|Unique identifier, if service runs on multiple machines 
+|sqsQueue|string OPTIONAL|Name of AWS SQS queue. If not send, defaults to 'supportQueue'
+
+## Create Message
+|Parameter|Type|Usage|
+|---|---|---|
+|subject|string|Subject of the message
+|text|string|Text of the message
+|level|string|Level of the message, if not set defaults to info. Available: error, warn, debug, verbose, info
+|block|integer|Seconds before the message is sent again (if the error occurs again). If Redis is not available, memory is used.
+
+
+## Links
+- [Website](https://www.admiralcloud.com/)
+- [Facebook](https://www.facebook.com/MediaAssetManagement/)
+
+## License
+Copyright AdmiralCloud AG, Mark Poepping

package/index.js

@@ -0,0 +1,98 @@
+const { SQSClient, SendMessageCommand } = require('@aws-sdk/client-sqs');
+
+const getLength = require('utf8-byte-length')
+const truncate = require('truncate-utf8-bytes')
+
+const NodeCache = require('node-cache')
+
+module.exports = {
+
+  aws: {},
+
+
+  init: function({ accessKeyId, secretAccessKey, region, accountId, serviceName, instanceId, sqsQueue, redisInstance, debug }) {
+    // check requirements
+    if (!debug) {
+      if (!accessKeyId) return { message: 'accessKeyId_required' }
+      if (!secretAccessKey) return { message: 'secretAccessKey_required' }
+      if (!region) return { message: 'region_required' }
+      if (!accountId) return { message: 'accountId_required' }
+    }
+    
+    if (accessKeyId && secretAccessKey) {
+        let awsParams = {
+        credentials: {
+          accessKeyId,
+          secretAccessKey
+        },
+        region: region || 'eu-central-1'
+      }
+      this.aws = {
+        sqs: new SQSClient(awsParams),
+        region,
+        accountId
+      }
+    }
+
+    this.serviceName = serviceName || 'SupportConnector'
+    this.instanceId = instanceId
+    this.sqsQueue = sqsQueue || 'supportQueue'
+    this.redisInstance = redisInstance
+    this.cache = new NodeCache()
+  },
+
+
+  createMessage: async function({ subject, text, level, block }) {
+    // check block time in Redis, fallback to memory
+    if (block) {
+      if (block < 1) block = 1 // make sure to use reasonable value!
+      const key = `${process.env.NODE_ENV}:supportConnector:${this.serviceName}:${Buffer.from(subject).toString('base64')}`
+      if (this.redisInstance) {
+        // OK if set for the first time, null if existing
+        let response = await this.redisInstance.set(key, 1, 'ex', block, 'nx')
+        if (response !== 'OK') {
+          return// { statusCode: 423, message: 'keyBlocked' }
+        }
+      }
+      else {
+        if (!this.cache.has(key)) {
+          this.cache.set(key, 1, block)
+        }
+        else {
+          return // 
+        }
+      }
+    }
+
+    const messagePayload = {
+      subject,
+      text,
+      level
+    }
+    const maxSize = 256 * 1024 // 256kb 
+    const recordLength = getLength(JSON.stringify(messagePayload))
+    if (recordLength > maxSize) {
+      // text must be truncated
+      const textLength = getLength(messagePayload.text)
+      const truncatedSize = textLength - (recordLength - maxSize)
+      messagePayload.text = truncate(messagePayload.text, truncatedSize)
+      console.log('AC-Support-Connector | Subject %s | Truncated to %s', subject, truncatedSize)
+    }  
+  
+    if (process.env.NODE_ENV === 'test') {
+      return messagePayload
+    }
+
+    const awsInput = {
+      QueueUrl: `https://sqs.${this.aws.region}.amazonaws.com/${this.aws.accountId}/${this.sqsQueue}`,
+      MessageBody: JSON.stringify(messagePayload)
+    }
+    const command = new SendMessageCommand(awsInput)
+    try {
+      await this.aws.sqs.send(command)
+    }
+    catch(e) {
+      console.log('AC-Support-Connector | Subject %s | Failed %j', subject, e?.message)
+    }
+  }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "ac-support-connector",
+  "author": "Mark Poepping (https://www.admiralcloud.com)",
+  "license": "MIT",
+  "repository": "admiralcloud/ac-support-connector",
+  "version": "0.0.1",
+  "dependencies": {
+    "@aws-sdk/client-sqs": "^3.236.0",
+    "node-cache": "^5.1.2",
+    "truncate-utf8-bytes": "^1.0.2",
+    "utf8-byte-length": "^1.0.4"
+  },
+  "devDependencies": {
+    "ac-semantic-release": "^0.3.4",
+    "chai": "^4.3.7",
+    "eslint": "^8.30.0",
+    "expect": "^29.3.1",
+    "ioredis": "^5.2.4",
+    "mocha": "^10.2.0"
+  },
+  "scripts": {
+    "test": "NODE_ENV=test mocha --reporter spec || :"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/test/test.js

@@ -0,0 +1,157 @@
+const { expect } = require('chai');
+
+const getLength = require("utf8-byte-length")
+const truncate = require("truncate-utf8-bytes")
+
+const Redis = require("ioredis");
+const redisInstance = new Redis() 
+
+const supCon = require('../index')
+
+const string1001 = new Array(512000).join('b')
+
+function timeout(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+
+describe('Basic tests', () => {
+  it('Test properties', async() => {
+    let params = {
+      subject: 'Failed',
+      text: 'This failed',
+      level: 'warn'
+    }
+    let response = await supCon.createMessage(params)
+    Object.keys(params).forEach(prop => {
+      const val = params[prop]
+      expect(response).to.have.property(prop, val)
+    })
+  })
+
+  it('Check truncated payload > 256KB - truncated', async() => {
+    let params = {
+      subject: 'Failed',
+      text: string1001
+    }
+    const maxSize = 256 * 1024 // 256kb 
+    const recordLength = getLength(JSON.stringify(params))
+    const textLength = getLength(params.text)
+    const truncated = truncate(params.text, textLength - (recordLength - maxSize))
+    let response = await supCon.createMessage(params)
+    expect(response.text).to.equal(truncated)
+  })
+
+  it('Check init - missing params', async() => {
+    let initParams = {
+      secretAccessKey: 'XXX',
+    }
+    let response = supCon.init(initParams)
+    expect(response.message).to.equal('accessKeyId_required')
+  })
+
+})
+
+describe('Block with Redis', () => {
+  it('Init with Redis', async() => {
+    const initParams = {
+      redisInstance,
+      debug: true
+    }
+    supCon.init(initParams)
+  })
+
+  it('Send message - should work', async() => {
+    let params = {
+      subject: 'Failed',
+      text: 'This failed',
+      level: 'warn',
+      block: 5
+    }
+    let response = await supCon.createMessage(params)
+    expect(response).to.have.property('subject', params.subject)
+  })
+
+  it('Send message - should be blocked', async() => {
+    let params = {
+      subject: 'Failed',
+      text: 'This failed',
+      level: 'warn',
+      block: 5
+    }
+    let response = await supCon.createMessage(params)
+    expect(response).to.be.undefined
+  })
+
+  it('Wait for timeout', async() => {
+    await timeout(5000)
+  }).timeout(10000)
+
+  it('Send message - should work again', async() => {
+    let params = {
+      subject: 'Failed',
+      text: 'This failed',
+      level: 'warn',
+      block: 5
+    }
+    let response = await supCon.createMessage(params)
+    expect(response).to.have.property('subject', params.subject)
+  })  
+})
+
+
+describe('Block with Memory', () => {
+
+  it('Init', () => {
+    supCon.init({
+      debug: true
+    })
+  })
+  
+  it('Send message - should work', async() => {
+    let params = {
+      subject: 'Failed',
+      text: 'This failed',
+      level: 'warn',
+      block: 5
+    }
+    let response = await supCon.createMessage(params)
+    expect(response).to.have.property('subject', params.subject)
+  })
+
+  it('Send message - should be blocked', async() => {
+    let params = {
+      subject: 'Failed',
+      text: 'This failed',
+      level: 'warn',
+      block: 5
+    }
+    let response = await supCon.createMessage(params)
+    expect(response).to.be.undefined
+  })
+
+  
+  it('Wait for timeout', async() => {
+    await timeout(5000)
+  }).timeout(10000)
+
+  it('Send message - should work again', async() => {
+    let params = {
+      subject: 'Failed',
+      text: 'This failed',
+      level: 'warn',
+      block: 5
+    }
+    let response = await supCon.createMessage(params)
+    expect(response).to.have.property('subject', params.subject)
+  })
+  
+  
+})
+
+
+describe('Cleanup', () => {
+  it('Close Redis', async() => {
+    redisInstance.quit()
+  })
+})