added batch logging

.gitignore

@@ -7,6 +7,5 @@ config/*.json
 config/facs/*.json
 logs
 sec
-package-lock.json
 *.swp
 *.swo

README.md

@@ -1,6 +1,6 @@
 # bfx-facs-grc-slack
 
-A facility that simplifies the integration of slack message service  via greanche service.
+A facility that simplifies the integration of slack message service via greanche service.
 
 ### Example configuration
 
@@ -11,7 +11,12 @@ A facility that simplifies the integration of slack message service  via greanch
     "worker": "rest:ext:slack",
     "max_length": 1024,
     "channel": "slack-channel",
-    "env": "development"
+    "env": "development",
+    "errorBatching": { // optional
+      "interval": 60000,
+      "maxSize": 50,
+      "maxMessageLength": 4000
+    }
   }
 }
 ```

index.js

@@ -3,6 +3,8 @@
 const util = require('util')
 const Base = require('bfx-facs-base')
 
+const { formatTime } = require('./utils/date-time')
+
 class GrcSlack extends Base {
   constructor (caller, opts, ctx) {
     super(caller, opts, ctx)
@@ -12,6 +14,34 @@ class GrcSlack extends Base {
     this.init()
 
     if (opts.conf) this.conf = opts.conf
+
+    if (this.conf.errorBatching && opts.lru) {
+      this._errorBatch = opts.lru
+      this._initErrorBatching()
+    }
+  }
+
+  _initErrorBatching () {
+    this._errorBatchTimer = setInterval(() => {
+      this._processBatchedErrors()
+    }, this.conf.errorBatching?.interval || 60000)
+
+    this._errorBatchTimer.unref()
+  }
+
+  async _stop (cb) {
+    if (this._errorBatchTimer) {
+      clearInterval(this._errorBatchTimer)
+      this._errorBatchTimer = null
+    }
+
+    try {
+      await this._processBatchedErrors()
+    } catch (err) {
+      console.error('Failed to process final batch of errors during shutdown', err)
+    } finally {
+      super._stop(cb)
+    }
   }
 
   message (reqChannel, message) {
@@ -21,7 +51,7 @@ class GrcSlack extends Base {
     const maxLength = slack.max_length || 1024
     const env = (slack.env) ? `Env: ${slack.env}, ` : ''
     const rawText = env + message
-    const text = (maxLength) ? rawText.substr(0, maxLength) : rawText
+    const text = (maxLength) ? rawText.slice(0, maxLength) : rawText
     const channel = reqChannel || slack.channel
     const send = [{ channel, text }]
 
@@ -41,6 +71,143 @@ class GrcSlack extends Base {
 
     return this.message(reqChannel, `${extraP}${errTag}${error}`)
   }
+
+  /**
+   * Batch log error to slack
+   * @param {string} reqChannel - Slack channel to log the error to, if not provided, the channel from the config will be used
+   * @param {Error} err - Error to log
+   * @param {string} sourceName - Source of the error
+   * @param {Object} payload - Payload to log
+   * @param {...any} extra - Additional information to log
+   */
+  async logErrorEnqueue (reqChannel, err, sourceName, payload, ...extra) {
+    if (!this._errorBatch) {
+      console.error('Error batching not initialized, falling back to direct log')
+      return this.logError(reqChannel, err, sourceName, payload, ...extra)
+    }
+
+    if (!reqChannel) {
+      reqChannel = this.conf.channel
+    }
+
+    try {
+      const errorKey = this._createErrorKey(reqChannel, err, sourceName)
+
+      const now = new Date()
+      let errorEntry = this._errorBatch.get(errorKey)
+
+      if (!errorEntry) {
+        errorEntry = {
+          errorMessage: err.message,
+          sourceName,
+          reqChannel,
+          payloads: [
+            { payload, extras: extra }
+          ],
+          count: 0,
+          firstSeen: now,
+          lastSeen: now
+        }
+        this._errorBatch.set(errorKey, errorEntry)
+      }
+
+      errorEntry.count++
+      errorEntry.lastSeen = now
+      errorEntry.payloads.push({ payload, extras: extra })
+    } catch (e) {
+      console.error('Error batching failed, falling back to direct log', e)
+      await this.logError(reqChannel, err, sourceName, payload, ...extra)
+    }
+  }
+
+  _createErrorKey (reqChannel, err, sourceName) {
+    const errorMsg = err?.message || 'Unknown error'
+    return `${reqChannel}:${sourceName}:${errorMsg}`
+  }
+
+  async _processBatchedErrors () {
+    if (!this._errorBatch || this._errorBatch.cache.length === 0) {
+      return
+    }
+
+    try {
+      const errorsByFunctionNameAndChannel = new Map()
+
+      const allEntries = Object.values(this._errorBatch.cache.cache || {})
+
+      for (const { value: errorEntry } of allEntries) {
+        const groupKey = `${errorEntry.reqChannel}:${errorEntry.sourceName}`
+        if (!errorsByFunctionNameAndChannel.has(groupKey)) {
+          errorsByFunctionNameAndChannel.set(groupKey, [])
+        }
+
+        const errorKey = this._createErrorKey(errorEntry.reqChannel, { message: errorEntry.errorMessage }, errorEntry.sourceName)
+        errorsByFunctionNameAndChannel.get(groupKey).push({ errorKey, ...errorEntry })
+      }
+
+      for (const [groupKey, errors] of errorsByFunctionNameAndChannel) {
+        const [reqChannel, sourceName] = groupKey.split(':')
+        await this._sendBatchedErrorMessage(reqChannel, sourceName, errors)
+      }
+    } catch (e) {
+      console.error('Failed to process batched errors', e)
+    } finally {
+      this._errorBatch.clear()
+    }
+  }
+
+  async _sendBatchedErrorMessage (reqChannel, sourceName, errors) {
+    const totalErrors = errors.reduce((sum, error) => sum + error.count, 0)
+    const timeRange = this._getTimeRange(errors)
+
+    let message = `*Batched Error Report - ${sourceName}*\n`
+    message += `*Summary:* ${totalErrors} errors across ${errors.length} types (${timeRange})\n\n`
+
+    let truncated = false
+    for (const error of errors.slice(0, 10)) {
+      if (truncated) break
+
+      message += `• *${error.errorMessage}* (${error.count}x)\n`
+      message += '  Payloads:\n'
+
+      for (const item of error.payloads.slice(0, 3)) {
+        let payloadStr = `    - ${JSON.stringify(item.payload)}\n`
+        if (Array.isArray(item.extras) && item.extras.length) {
+          payloadStr += `     Extras: ${JSON.stringify(item.extras)}\n`
+        }
+
+        if (message.length + payloadStr.length > (this.conf.errorBatching?.maxMessageLength || 4000)) {
+          message += `\n... message truncated (${errors.length - errors.indexOf(error)} more error types)`
+          truncated = true
+          break
+        }
+
+        message += payloadStr
+      }
+
+      if (error.payloads.length > 3) {
+        message += `    ... and ${error.payloads.length - 3} more payloads\n`
+      }
+    }
+
+    if (errors.length > 10 && !truncated) {
+      message += `\n... and ${errors.length - 10} more error types`
+    }
+
+    await this.logError(reqChannel, message)
+  }
+
+  _getTimeRange (errors) {
+    const allTimes = errors.flatMap(error => [error.firstSeen, error.lastSeen])
+    const earliest = new Date(Math.min(...allTimes))
+    const latest = new Date(Math.max(...allTimes))
+
+    if (earliest.getTime() === latest.getTime()) {
+      return formatTime(earliest)
+    }
+
+    return `${formatTime(earliest)} - ${formatTime(latest)}`
+  }
 }
 
 module.exports = GrcSlack

jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  testEnvironment: 'node',
+  testMatch: ['<rootDir>/test/**/*.test.js'],
+  verbose: true
+}