Added plugin framework + re-added Slack integration

README.md

@@ -339,6 +339,35 @@ The class `LogMessage` provides the ability to generate string messages on deman
 
 For more details, check out the `LogMessage` class [documentation](https://jongpie.github.io/NebulaLogger/logger-engine/LogMessage).
 
+### Adding Custom Post-Processors for Log\_\_c and LogEntry\_\_c
+
+If you want to add your own automation to the `Log__c` or `LogEntry__c` objects, you can leverage Apex or Flow to define "post-processors" - the logger system will then automatically run the post-processors after each trigger event (BEFORE_INSERT, BEFORE_UPDATE, AFTER_INSERT, AFTER_UPDATE, and so on)
+
+-   Flow post-processors: your Flow should be built with these input parameters:
+    1. `triggerOperationType` - The name of the current trigger operation (such as BEFORE_INSERT, BEFORE_UPDATE, etc.)
+    2. `records` - The list of logger records being processed (`Log__c` or `LogEntry__c` records)
+    3. `oldRecords` - The list of logger records as they exist in the datatabase - this is only populated when running in the context of `Trigger.isUpdate`
+-   Apex post-processors: your Apex class should implement `LoggerSObjectPostProcessor`. For example:
+
+    ```java
+    public class ExamplePostProcessor implements LoggerSObjectPostProcessor {
+        public void execute(Trigger.operationType triggerOperationType, List<Log__c> logs, Map<Id, SObject> oldLoggerRecordsById) {
+            switch on triggerOperationType {
+                when BEFORE_INSERT {
+                    for (Log__c log : logs) {
+                        log.Status__c = 'On Hold';
+                    }
+                }
+            }
+        }
+    }
+
+    ```
+
+Once you've created your Apex or Flow post-processor(s), you will also need to configure the custom metadata type `LoggerSObjectHandlerConfiguration__mdt` to specify the name(s) of Apex class and Flow to run.
+
+![Logger Handler Configuration](./content/logger-handler-configuration.png)
+
 ## Managing Logs
 
 To help development and support teams better manage logs (and any underlying code or config issues), some fields on `Log__c` are provided to track the owner, priority and status of a log. These fields are optional, but are helpful in critical environments (production, QA sandboxes, UAT sandboxes, etc.) for monitoring ongoing user activities.

docs/index.md

@@ -56,6 +56,14 @@ Manages setting fields on `Log__c` before insert & before update
 
 Manages mass deleting `Log__c` records that have been selected by a user on a `Log__c` list view
 
+### [LoggerSObjectHandler](log-management/LoggerSObjectHandler)
+
+Abstract class used by trigger handlers for shared logic
+
+### [LoggerSObjectPostProcessor](log-management/LoggerSObjectPostProcessor)
+
+Interface used to define custom logic to run when DML statements occur on `Log__c` or `LogEntry__c`
+
 ### [RelatedLogEntriesController](log-management/RelatedLogEntriesController)
 
 Controller class for the component RelatedLogEntries

docs/log-management/LogEntryEventHandler.md

@@ -30,4 +30,18 @@ Processes `LogEntryEvent__e` platform events and normalizes the data into `Log__
 
 Runs the trigger handler's logic for the `LogEntryEvent__e` platform event object
 
+#### `getSObjectType()` → `SObjectType`
+
+Returns SObject Type that the handler is responsible for processing
+
+##### Return
+
+**Type**
+
+SObjectType
+
+**Description**
+
+The instance of `SObjectType`
+
 ---

docs/log-management/LogEntryHandler.md

@@ -20,4 +20,18 @@ Manages setting fields on `LogEntry__c` before insert & before update
 
 Runs the trigger handler's logic for the `LogEntry__c` custom object
 
+#### `getSObjectType()` → `SObjectType`
+
+Returns SObject Type that the handler is responsible for processing
+
+##### Return
+
+**Type**
+
+SObjectType
+
+**Description**
+
+The instance of `SObjectType`
+
 ---

docs/log-management/LogHandler.md

@@ -20,4 +20,18 @@ Manages setting fields on `Log__c` before insert & before update
 
 Runs the trigger handler's logic for the `Log__c` custom object
 
+#### `getSObjectType()` → `SObjectType`
+
+Returns SObject Type that the handler is responsible for processing
+
+##### Return
+
+**Type**
+
+SObjectType
+
+**Description**
+
+The instance of `SObjectType`
+
 ---

docs/log-management/LoggerSObjectHandler.md

@@ -0,0 +1,33 @@
+---
+layout: default
+---
+
+## LoggerSObjectHandler class
+
+Abstract class used by trigger handlers for shared logic
+
+---
+
+### Constructors
+
+#### `LoggerSObjectHandler()`
+
+---
+
+### Methods
+
+#### `getSObjectType()` → `SObjectType`
+
+Returns the SObject Type that the handler is responsible for processing
+
+##### Return
+
+**Type**
+
+SObjectType
+
+**Description**
+
+The instance of `SObjectType`
+
+---

docs/log-management/LoggerSObjectPostProcessor.md

@@ -0,0 +1,15 @@
+---
+layout: default
+---
+
+## LoggerSObjectPostProcessor interface
+
+Interface used to define custom logic to run when DML statements occur on `Log__c` or `LogEntry__c`
+
+---
+
+### Methods
+
+#### `execute(TriggerOperation triggerOperationType, List<SObject> loggerRecords, Map<Id, SObject> oldLoggerRecordsById)` → `void`
+
+---

nebula-logger/main/log-management/classes/LogEntryEventHandler.cls

@@ -7,7 +7,7 @@
  * @group Log Management
  * @description Processes `LogEntryEvent__e` platform events and normalizes the data into `Log__c` and `LogEntry__c` records
  */
-public without sharing class LogEntryEventHandler {
+public without sharing class LogEntryEventHandler extends LoggerSObjectHandler {
     private static final Map<String, Log__c> TRANSACTION_ID_TO_LOG = new Map<String, Log__c>();
 
     @testVisible
@@ -33,10 +33,22 @@ public without sharing class LogEntryEventHandler {
         this.topicNames = new Set<String>();
     }
 
+    /**
+     * @description Returns SObject Type that the handler is responsible for processing
+     * @return      The instance of `SObjectType`
+     */
+    public override SObjectType getSObjectType() {
+        return Schema.LogEntryEvent__e.SObjectType;
+    }
+
     /**
      * @description Runs the trigger handler's logic for the `LogEntryEvent__e` platform event object
      */
     public void execute() {
+        if (this.configuration.IsEnabled__c == false) {
+            return;
+        }
+
         if (this.logEntryEvents.isEmpty() == false) {
             this.upsertLogs();
             this.insertLogEntries();

nebula-logger/main/log-management/classes/LogEntryHandler.cls

@@ -7,22 +7,37 @@
  * @group Log Management
  * @description Manages setting fields on `LogEntry__c` before insert & before update
  */
-public without sharing class LogEntryHandler {
+public without sharing class LogEntryHandler extends LoggerSObjectHandler {
     // Trigger-based variables - tests can override these with mock objects
     @testVisible
     private List<LogEntry__c> logEntries;
     @testVisible
+    private Map<Id, LogEntry__c> oldLogEntriesById;
+    @testVisible
     private TriggerOperation triggerOperationType;
 
     public LogEntryHandler() {
         this.logEntries = (List<LogEntry__c>) Trigger.new;
+        this.oldLogEntriesById = (Map<Id, LogEntry__c>) Trigger.oldMap;
         this.triggerOperationType = Trigger.operationType;
     }
 
+    /**
+     * @description Returns SObject Type that the handler is responsible for processing
+     * @return      The instance of `SObjectType`
+     */
+    public override SObjectType getSObjectType() {
+        return Schema.LogEntry__c.SObjectType;
+    }
+
     /**
      * @description Runs the trigger handler's logic for the `LogEntry__c` custom object
      */
     public void execute() {
+        if (this.configuration.IsEnabled__c == false) {
+            return;
+        }
+
         switch on this.triggerOperationType {
             when BEFORE_INSERT {
                 this.setCheckboxFields();
@@ -39,6 +54,9 @@ public without sharing class LogEntryHandler {
                 this.setCheckboxFields();
             }
         }
+
+        // Run any post-processors
+        this.executePostProcessors(this.logEntries, this.oldLogEntriesById);
     }
 
     private void setCheckboxFields() {

nebula-logger/main/log-management/classes/LogHandler.cls

@@ -7,7 +7,7 @@
  * @group Log Management
  * @description Manages setting fields on `Log__c` before insert & before update
  */
-public without sharing class LogHandler {
+public without sharing class LogHandler extends LoggerSObjectHandler {
     private static final Organization ORGANIZATION = [SELECT Id, InstanceName, IsSandbox FROM Organization];
 
     @testVisible
@@ -38,10 +38,22 @@ public without sharing class LogHandler {
         this.triggerOperationType = Trigger.operationType;
     }
 
+    /**
+     * @description Returns SObject Type that the handler is responsible for processing
+     * @return      The instance of `SObjectType`
+     */
+    public override SObjectType getSObjectType() {
+        return Schema.Log__c.SObjectType;
+    }
+
     /**
      * @description Runs the trigger handler's logic for the `Log__c` custom object
      */
     public void execute() {
+        if (this.configuration.IsEnabled__c == false) {
+            return;
+        }
+
         switch on this.triggerOperationType {
             when BEFORE_INSERT {
                 this.setOrgReleaseCycle();
@@ -58,6 +70,9 @@ public without sharing class LogHandler {
                 this.shareLogsWithLoggingUsers();
             }
         }
+
+        // Run any post-processors
+        this.executePostProcessors(this.logs, this.oldLogsById);
     }
 
     private void setOrgReleaseCycle() {

nebula-logger/main/log-management/classes/LoggerSObjectHandler.cls

@@ -0,0 +1,92 @@
+//------------------------------------------------------------------------------------------------//
+// This file is part of the Nebula Logger project, released under the MIT License.                //
+// See LICENSE file or go to https://github.com/jongpie/NebulaLogger for full license details.    //
+//------------------------------------------------------------------------------------------------//
+
+/**
+ * @group Log Management
+ * @description Abstract class used by trigger handlers for shared logic
+ */
+public abstract class LoggerSObjectHandler {
+    @testVisible
+    private static Map<SObjectType, LoggerSObjectHandlerConfiguration__mdt> configurationsBySObjectType = loadConfigurations();
+
+    private static Map<SObjectType, LoggerSObjectHandlerConfiguration__mdt> loadConfigurations() {
+        DescribeSObjectResult configDescribe = Schema.LoggerSObjectHandlerConfiguration__mdt.SObjectType.getDescribe();
+
+        // When using CMDT's getAll(), it does not return relationship fields for EntityDefinition fields...
+        // ... so instead query the LoggerSObjectHandlerConfiguration__mdt CMDT object
+        List<LoggerSObjectHandlerConfiguration__mdt> configurations = [
+            SELECT Id, IsEnabled__c, PostProcessorApexClassName__c, PostProcessorFlowApiName__c, SObjectType__r.QualifiedApiName
+            FROM LoggerSObjectHandlerConfiguration__mdt
+        ];
+
+        Map<SObjectType, LoggerSObjectHandlerConfiguration__mdt> configsBySObjectType = new Map<SObjectType, LoggerSObjectHandlerConfiguration__mdt>();
+        for (LoggerSObjectHandlerConfiguration__mdt config : configurations) {
+            // CMDT entity-definition relationship fields are weird, so skip some headaches by copying the Qualified API name
+            config.SObjectType__c = config.SObjectType__r.QualifiedApiName;
+
+            // Schema.getGlobalDescribe() is the worst, so don't use it
+            SObjectType sobjectType = ((SObject) Type.forName(config.SObjectType__c).newInstance()).getSObjectType();
+
+            configsBySObjectType.put(sobjectType, config);
+        }
+        return configsBySObjectType;
+    }
+
+    protected LoggerSObjectHandlerConfiguration__mdt configuration;
+
+    public LoggerSObjectHandler() {
+        this.configuration = getConfiguration(this.getSObjectType());
+    }
+
+    /**
+     * @description Returns the SObject Type that the handler is responsible for processing
+     * @return      The instance of `SObjectType`
+     */
+    public abstract SObjectType getSObjectType();
+
+    protected void executePostProcessors(List<SObject> loggerRecords, Map<Id, SObject> oldLoggerRecordsById) {
+        if (loggerRecords == null) {
+            return;
+        }
+
+        this.executePostProcessorApexClass(this.configuration?.PostProcessorApexClassName__c, loggerRecords, oldLoggerRecordsById);
+        this.executePostProcessorFlow(this.configuration?.PostProcessorFlowApiName__c, loggerRecords, oldLoggerRecordsById);
+    }
+
+    private LoggerSObjectHandlerConfiguration__mdt getConfiguration(SObjectType sobjectType) {
+        LoggerSObjectHandlerConfiguration__mdt configuration = configurationsBySObjectType.get(sobjectType);
+
+        if (configuration == null) {
+            configuration = new LoggerSObjectHandlerConfiguration__mdt(IsEnabled__c = true, SObjectType__c = sobjectType.getDescribe().getName());
+
+            configurationsBySObjectType.put(sobjectType, configuration);
+        }
+
+        return configuration;
+    }
+
+    private void executePostProcessorApexClass(String apexClassName, List<SObject> loggerRecords, Map<Id, SObject> oldLoggerRecordsById) {
+        if (String.isBlank(apexClassName) || Type.forName(apexClassName) == null) {
+            return;
+        }
+
+        LoggerSObjectPostProcessor apexPostProcessor = (LoggerSObjectPostProcessor) Type.forName(apexClassName).newInstance();
+        apexPostProcessor.execute(Trigger.operationType, loggerRecords, oldLoggerRecordsById);
+    }
+
+    private void executePostProcessorFlow(String flowApiName, List<SObject> loggerRecords, Map<Id, SObject> oldLoggerRecordsById) {
+        if (String.isBlank(flowApiName)) {
+            return;
+        }
+
+        Map<String, Object> flowInputs = new Map<String, Object>();
+        flowInputs.put('triggerOperationType', Trigger.operationType?.name());
+        flowInputs.put('records', loggerRecords);
+        flowInputs.put('oldRecords', oldLoggerRecordsById?.values());
+
+        Flow.Interview flowPostProcessor = Flow.Interview.createInterview(flowApiName, flowInputs);
+        flowPostProcessor.start();
+    }
+}

nebula-logger/main/log-management/classes/LoggerSObjectHandler.cls-meta.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ApexClass xmlns="http://soap.sforce.com/2006/04/metadata">
+    <apiVersion>51.0</apiVersion>
+    <status>Active</status>
+</ApexClass>

nebula-logger/main/log-management/classes/LoggerSObjectPostProcessor.cls

@@ -0,0 +1,12 @@
+//------------------------------------------------------------------------------------------------//
+// This file is part of the Nebula Logger project, released under the MIT License.                //
+// See LICENSE file or go to https://github.com/jongpie/NebulaLogger for full license details.    //
+//------------------------------------------------------------------------------------------------//
+
+/**
+ * @group Log Management
+ * @description Interface used to define custom logic to run when DML statements occur on `Log__c` or `LogEntry__c`
+ */
+ global interface LoggerSObjectPostProcessor {
+    void execute(TriggerOperation triggerOperationType, List<SObject> loggerRecords, Map<Id, SObject> oldLoggerRecordsById);
+}

nebula-logger/main/log-management/classes/LoggerSObjectPostProcessor.cls-meta.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ApexClass xmlns="http://soap.sforce.com/2006/04/metadata">
+    <apiVersion>51.0</apiVersion>
+    <status>Active</status>
+</ApexClass>