elsa-workflows/elsa-core
Elsa Core
Elsa Core is a workflow engine framework designed for defining, executing, and managing long-running business processes. It functions as a distributed workflow orchestrator and event-driven trigger system, capable of operating as a multi-tenant platform with secure data isolation.
The project distinguishes itself through a flexible approach to workflow definitions, supporting a visual drag-and-drop designer, programmatic C# definitions, and portable JSON specifications. It provides a highly extensible architecture allowing for the development of custom activities and the use of a dynamic expression engine that evaluates C#, JavaScript, and Python at runtime.
The framework covers a broad range of operational capabilities, including state persistence via bookmarks, distributed locking for cluster coordination, and complex execution patterns such as parallel branching and asynchronous dispatching. It integrates extensively with external systems through HTTP endpoints, webhooks, and message bus triggers, while providing comprehensive observability via OpenTelemetry tracing and detailed execution journaling.
The system supports deployment via Docker and Kubernetes and provides persistence options for SQL Server, PostgreSQL, and MongoDB.
Features
- Durable Workflow Execution Engines - Provides a durable execution engine that processes defined workflow tasks and logic in the background with state persistence.
- Workflow Orchestrators - An orchestration system that coordinates scheduled jobs and workflow execution across a cluster using distributed locking.
- Visual Workflow Builders - Ships a drag-and-drop browser interface for constructing workflow logic and monitoring execution history.
- Stateful Workflow Persistence - Provides mechanisms to suspend workflow execution by persisting the current state to a database for later resumption.
- Sequential Step Orchestrators - Captures output data from activities and stores it in variables to be used as input for subsequent steps.
- Workflow Branching Control - Defines activity ports to schedule and manage child execution paths for complex logic.
- Workflow State Persistences - Persists runtime data to allow workflows to survive process restarts and resume execution.
- Workflow Execution Engines - Implements a runtime engine capable of executing workflows synchronously within the current process for immediate results.
- Distributed Execution Locking - The workflow engine prevents multiple nodes from acting on the same workflow instance concurrently using distributed locking.
- Workflow Instance Initialization - Creates and executes new workflow instances using defined specifications, input parameters, and correlation tracking.
- Variable Persistence - Defines and persists variables with specific data types and scopes across workflow executions.
- Multi-Tenant Data Management - Segregates workflow definitions and runtime data by tenant ID to prevent cross-tenant access.
- Tenant Identification Strategies - Resolves active tenants by inspecting HTTP headers, hostnames, or user identity claims.
- Tenant Configurations - Maintains a registry of authorized tenants via configuration files or a persistent database.
- Tenant-Based Partitioning - Segregates workflow definitions and runtime state using tenant identifiers to ensure secure data isolation.
- Workflow Lifecycle Management - Manages the full lifecycle of workflow definitions, including creation, versioning, and publishing.
- Workflow Schedulers - Provides capabilities to trigger workflow execution repeatedly based on fixed time intervals or cron expressions.
- Stateful Workflow Engines - A framework for defining, executing, and managing long-running business processes with support for state persistence and activity orchestration.
- Cluster Coordination - Coordinates timers and cron triggers across a cluster using a shared database to ensure exactly-once execution.
- Distributed Locks - Synchronizes access to shared resources across clusters using external providers to prevent concurrent execution.
- Event-Driven Workflow Triggers - Indexes event payloads to automatically initiate or resume workflow instances when matching HTTP requests or messages arrive.
- Distributed Lock Coordination - Uses database locks to ensure scheduled tasks execute exactly once across multiple nodes.
- Runtime Coordination - The workflow engine coordinates execution, locking, and scheduling across replicas using external providers like RabbitMQ.
- Distributed Resumption Locking - Acquires distributed locks to ensure only one instance processes a workflow resume request in a cluster.
- Expression Evaluators - Provides a runtime expression engine that evaluates C#, JavaScript, and Python to calculate activity inputs dynamically.
- Scope Chain Management - Implements a hierarchical scope chain to resolve variables across workflow and container levels.
- Activity Property Rendering - Provides a context-sensitive properties panel to configure activity inputs and output bindings.
- Custom Activity Development - Allows the development of reusable building blocks with defined inputs, outputs, and execution logic.
- Distributed Job Locking - Uses a shared lock provider to prevent concurrent processing of the same workflow instance across multiple cluster nodes.
- Executable Activity Definitions - Specifies the data requirements and results for activities using typed properties and dynamic expressions.
- Instance Resumptions - Implements state persistence via bookmarks to allow workflows to pause and resume from specific points.
- Bookmark Identifiers - Restarts specific suspended workflow instances using unique bookmark identifiers.
- JSON Workflow Specifications - Allows executable process logic to be defined and versioned as structured JSON documents.
- Execution Graph Compositions - Orchestrates complex logic by grouping tasks into sequences, flowcharts, or parallel execution graphs.
- Programmatic Workflow Authoring - The workflow engine creates execution logic using classes to build sequences of activities without a designer.
- Workflow Definitions - Supports defining executable process logic via C# code, JSON specifications, or a visual designer.
- Type-Safe Definition Publishing - Creates and versions workflow definitions using type-safe clients to establish execution logic.
- State Persistence - Implements bookmark-based checkpointing to save execution state and pause workflows until a matching event occurs.
- Workflow Routing - Directs the sequence of workflow activities based on the specific result of a preceding task.
- Workflow Triggers - Implements event-driven mechanisms to start or resume workflow executions upon receiving specific messages from a bus.
- Workflow Versioning - Implements immutable versioning and migration strategies to maintain consistency for long-running processes.
- Workflow Resumption IDs - Restarts suspended workflows by matching external events to bookmarks using correlation IDs.
- Bookmark-Based Resumptions - Implements state persistence via bookmarks that allow workflows to pause and resume based on external events.
- Workflow Execution APIs - Exposes APIs that allow external applications to programmatically trigger and manage workflow runs via REST endpoints.
- Public HTTP Endpoints - Assigns publicly accessible HTTP endpoints to workflows so they can be triggered by external web requests.
- Sub-Workflow Outcome Mapping - Defines result ports for sub-workflows, enabling parent workflows to branch based on the outcome of the nested process.
- Workflow Unit Testing - Enables verification of workflow logic by executing definitions with specific inputs and asserting on the outputs.
- Workflow State Integration Testing - Validates state changes by running activities within a complete workflow context using specialized fixtures.
- PostgreSQL Persistence - Utilizes PostgreSQL for storing workflow management and runtime execution data.
- Shared Transactional Scopes - The workflow engine shares a database or transaction scope between the engine and application-specific data models.
- MongoDB Persistence - Provides a persistence provider for storing workflow definitions and execution logs in MongoDB.
- Data Plane Isolation Topologies - Determines if management and runtime data reside in shared or isolated databases to enable independent scaling.
- Workflow Isolation - A platform that segregates workflow definitions and runtime data by tenant ID to ensure secure data isolation.
- SQL Server Persistence - Persists workflow definitions and runtime state in SQL Server for transactional consistency.
- Child Workflow Orchestration - Supports invoking and managing separate child workflows from within a parent process, including optional result synchronization.
- Workflow Fan-Out Patterns - Triggers multiple child workflow instances from a parent to support synchronized or fire-and-forget execution.
- Runtime Workflow Alterations - Creates proprietary alteration types to modify workflow behavior or state during execution.
- External API Clients - Ships standardized interfaces for executing HTTP requests to remote REST services to capture data for workflow steps.
- Instance State Alterations - Allows modifying variables, canceling activities, or migrating versions of active workflow instances at runtime.
- Webhook Triggers - Sends HTTP requests to configured external URLs to notify other systems when specific workflow activities execute.
- Workflow Search Interfaces - Provides interfaces to search and filter workflow instances using status, correlation IDs, and other metadata.
- Runtime Variable Manipulation - Provides the ability to inspect and modify variables in running or suspended workflows to adjust their behavior.
- Workflow Execution Scaling - The workflow engine distributes workflow processing across multiple nodes in a cluster to handle high volumes.
- Delayed Executions - Pauses activity execution for a specified duration and resumes automatically once a timer expires.
- Kubernetes Orchestration - The workflow engine orchestrates the installation of the system on Kubernetes clusters using Helm charts or YAML.
- Instance Cancellation - Allows stopping long-running workflow instances and the removal of all associated bookmarks.
- Workflow Security - Controls access to the visual designer and runtime using authentication schemes and authorization policies.
- Message Emitters - Provides programmatic interfaces for sending strongly typed message payloads into messaging channels to notify other components.
- HTTP Request Orchestrators - Configures and executes dynamic web service requests and processes response content based on HTTP status codes.
- Message Bus Integrations - Integrates with service bus protocols to trigger workflows or publish messages in reaction to domain events.
- Tokenized Resumption Endpoints - Generates tokenized HTTP URLs that enable external systems to safely resume paused workflows via POST requests.
- Context Extensions - The workflow engine injects custom assemblies and global methods into the expression evaluator for domain-specific logic.
- Custom Script Handlers - The workflow engine integrates custom expression handlers to support proprietary languages for calculating variable values.
- JavaScript Runtimes - The workflow engine executes JavaScript code within a workflow to manipulate data and access instance variables.
- Python Runtimes - The workflow engine executes dynamic Python scripts to manipulate variables and retrieve execution context metadata.
- Text Templating Engines - Injects workflow variables and metadata into text strings using a dynamic templating engine.
- API Access Security - Secures management endpoints using API keys, JWT tokens, and OIDC integration.
- Bearer Token Authentication - Protects REST API endpoints by requiring valid bearer tokens in the authorization header.
- External Identity Provider Integration - Delegates user authentication to external identity providers using standard protocols.
- User Role Management - Handles user identities and role assignments through a built-in management system.
- Identity and Access Management - Provides a system for configuring users, roles, and granular permissions to secure workflow endpoints.
- OpenID Connect Support - Implements OpenID Connect for secure user sign-in and API communication via external identity providers.
- Permission-Based Access Control - Validates permission claims on requests to ensure users have the authority to perform specific actions.
- Concurrent Aggregators - Supports concurrent signal aggregation by waiting for multiple asynchronous branches to complete before proceeding.
- Asynchronous Workflow Management - Queues workflows for background execution via a mediator to support high-throughput process orchestration.
- Workflow Dispatchers - The workflow engine extends dispatching logic to implement background processing or priority queuing via a custom dispatcher.
- Asynchronous Dispatchers - Implements a mediator-based dispatcher to decouple API triggers from background workflow processing.
- Bulk Instance Alterations - The workflow engine processes changes across multiple instances asynchronously by applying a filter in the background.
- Error Handling Strategies - Defines strategies for determining whether a workflow should halt or continue after an error occurs.
- Retry Policies - Configures retry counts and exponential backoff strategies for activities interacting with external services.
- Test Harnesses - Uses test harnesses to simulate execution contexts and validate activity logic without running the full engine.
- Fault-Tolerant Workflow Execution - Implements resilient process execution by emitting structured faults to an incident pipeline for recovery.
- Workflow Instance Correlation - Associates multiple workflow instances using correlation IDs to group related activities and track execution paths.
- Module-Based Extensions - The workflow engine encapsulates related functionality into modules that are registered during application startup.
- Method-to-Activity Exposure - Turns public methods of a host class into workflow activities where parameters serve as inputs.
- Workflow Data Management - Manages the definition and lifecycle of input parameters provided at start and result values returned upon completion.
- Workflow Fault Diagnostics - Captures fault information from failed workflows to precisely identify the exception that caused the failure.
- Workflow Monitoring - Provides tools for identifying and querying execution errors linked to specific workflow instances and activities.
- Cross-Instance Correlation Tracking - Links independent workflow instances using shared identifiers to trace complex execution paths.
- Parallel Execution - Executes multiple workflow branches simultaneously to perform concurrent tasks within a process graph.
- Activity Execution Logs - The workflow engine stores detailed records of activity inputs and timestamps for deep-dive debugging of nodes.
- Application Performance Monitoring - Identifies system bottlenecks by tracking lock acquisition times and detailed execution traces.
- Background Job Schedulers - Executes long-running activities in the background to prevent blocking the main execution thread.
- Error Tracking - Captures unhandled exceptions and records them as incidents linked to specific workflow instances.
- Execution Audit Journals - Maintains an ordered journal of execution events to provide a detailed timeline of every workflow run.
- Execution History Auditors - Provides tools for inspecting the historical state and outcomes of workflow executions to verify branching and sequences.
- Execution Logs - Records operational events and status updates during execution to assist with monitoring and debugging.
- Trigger-Based Activity Development - Builds custom activities that respond to events or HTTP requests using scheduling infrastructure.
- Execution Tracing - Publishes execution spans and metrics via OpenTelemetry to analyze the performance of individual activities.
- Distributed Tracing and Execution Analysis - Integrates OpenTelemetry to instrument workflow activities with spans and metrics for distributed execution tracing.
- Metric and Performance Monitors - Tracks workflow health through telemetry metrics such as execution time and failure rates.
- Observability Instrumentation - Implements distributed tracing and performance metrics using OpenTelemetry instrumentation throughout the execution lifecycle.
- OpenTelemetry Exporters - Publishes workflow spans and metrics to OTLP-compatible tooling for external tracing and analysis.
- Workflow Trigger Testing - Provides mechanisms to await and verify workflows that rely on external triggers and asynchronous events.
- Activity Logic Testing - Allows developers to isolate and verify individual activity logic using dedicated test fixtures.
- Activity Picker Configuration - Provides a customizable visual layout and organization for the activity selection menu.
- Navigation Extensions - Allows the injection of custom navigation elements and action buttons into the global application bar.
- Custom Property Editors - Maps backend UI hints to specialized rendering handlers for activity property editors.
- Interface Surface Extensions - Enables the addition of custom tabs, panels, and editors to extend the management interface.
- Input Decorations - Adds helper UI, warnings, and toolbars around editor components using field extension handlers.
- Management Surface Embedding - Integrates editors, definition lists, and instance viewers into an application shell as custom elements.
- Custom Navigation Items - Enables the registration of custom top-level navigation items and menu entries for specialized modules.
- General Purpose Orchestration - Workflow library for the .NET Standard ecosystem.
