dtm-labs/dtm

Features

• Distributed Transaction Coordinators - Acts as a centralized coordinator managing the execution sequence and state of distributed operations across independent services.
• Saga Coordinators - Acts as a specialized coordinator for managing distributed transactions through local events and compensating rollback operations.
• Transaction Idempotency - Filters duplicate requests and blocks null compensation, suspension, and stale operations to maintain transactional correctness.
• Distributed Atomic Transactions - Combines business logic operations with a global transaction commit to ensure both succeed or fail together.
• Distributed Transaction Participants - Connects with MySQL, Redis, MongoDB, and Postgres as active participants in a distributed transaction.
• Global Transaction Session Persistence - Stores distributed transaction state and session information across various backends like MySQL, Redis, and MongoDB.
• SDK Integrations - Provides language-specific SDKs for heterogeneous services to participate in coordinated transactions.
• Automatic Completion Guarantees - Implements automatic retries for failed or interrupted operations after a process crash to ensure transactions reach a finished state.
• Crash Recovery Resumptions - Queries the local database after a restart to determine the status of pending transactions and resume execution.
• gRPC Microservices Integration - Accepts transaction requests over HTTP and gRPC to integrate with diverse service communication patterns.
• Multi-Protocol Transaction Orchestration - Coordinates multi-service operations across TCC, SAGA, XA, and transaction message protocols to ensure data consistency.
• Transactional Message Coordination - Guarantees atomic execution of local database operations and remote message delivery without requiring a message queue.
• Polyglot Workflow Orchestration - Connects various language runtimes into a single transaction workflow to ensure consistent data processing.
• Compensating Action Definitions - Allows registering specific rollback actions for each step to undo partial progress when any transaction step fails.
• Rollback Workflows - Records completed steps and executes compensating actions to restore a consistent state when a distributed operation fails.
• Automatic Compensation Coordination - Triggers automatic rollback operations for completed sub-transactions when a subsequent step in the process fails.
• Two-Phase Commit Protocols - Guarantees atomic execution of local business operations and message submission using a prepared state and asynchronous confirmation.
• Distributed Transaction Managers - Implements a system for managing complex distributed operations as sagas with automated compensation logic to avoid common transaction pitfalls.
• Distributed Transaction Patterns - Supports multiple consistency patterns including Saga, TCC, XA, and Outbox to match specific application requirements.
• Operation Idempotency - Filters duplicate requests for the same transaction to ensure business logic executes exactly once.
• Request-Level Idempotency - Prevents duplicate side effects by tracking request identifiers and blocking stale or repeated transactional calls.
• Database-Backed Persistence - Persists transaction logs and progress in external databases to ensure durability and support horizontal scalability.
• Microservice Orchestration - Connects services written in different programming languages via HTTP or gRPC to participate in coordinated business workflows.
• Transactional Workflow Execution - Runs user-defined sequences of transactional branches with individual forward and rollback logic as a single atomic unit.
• Workflow Compensation Systems - Implements automated rollback and cleanup logic by invoking compensating actions when any step in a distributed workflow fails.
• High-Concurrency Sales Systems - Coordinates inventory deduction and order creation to maintain eventual consistency during high-volume flash sales.
• Cache Consistency Managers - Manages consistency between Redis cache and database records using two-phase message transactions.
• Strongly Consistent Cache Reads - Routes all data reads through the cache and utilizes distributed transactions to update database and cache atomically.
• Distributed Cache Synchronizers - Synchronizes cached data in Redis with the final state of database records after a distributed transaction completes.
• Transactional Cache Updates - Uses a two-phase message pattern to atomically update the database and asynchronously update the cache for eventual consistency.
• Memory-Optimized Processing - Processes thousands of requests per second by executing inventory checks and global transactions in memory.
• Inventory Caches - Maintains precise alignment between Redis inventory and orders under extreme concurrency for flash sales.
• Pluggable Storage Backends - Supports persisting transaction progress in MySQL, Redis, BoltDB, or MongoDB to balance performance and durability.
• Crash Recovery Systems - Queries the local database after a crash to determine the prepared transaction's state and resume or abort the global transaction.
• Horizontal Scaling Strategies - Distributes transaction coordination across multiple nodes to ensure high availability and handle increased load.
• Lean Infrastructure Dependencies - Runs with only a database server as an external dependency, removing the need for message queues.
• Reliable Message Delivery - Guarantees atomic delivery of events without external message queues by implementing the outbox and two-phase messaging patterns.
• Queue-less Asynchronous Dispatch - Triggers remote service calls asynchronously without requiring dedicated message queue infrastructure.
• Sub-Transaction Branching - Executes each service call as an independent branch with its own forward and rollback logic via a central orchestrator.
• Transaction State Backchecks - Queries the local database after a crash to determine transaction status and resume or abort the global process.
• Messaging Reliability - Uses Outbox or two-phase message patterns to ensure messages reach subscribers without data loss.
• Message Delivery Guarantees - Guarantees eventual delivery of messages across services using a two-phase message pattern.
• Polyglot Worker Protocols - Uses language-specific SDKs to connect heterogeneous services to the coordinator via HTTP or gRPC.
• Distributed Transaction Anomaly Prevention - The project skips compensating operations when the corresponding forward operation was never executed to avoid unintended side effects.
• Message Table Elimination - Eliminates the need for message queues and polling tasks by using a two-phase commit approach for eventual consistency.
• Mixed Synchronous and Asynchronous Dispatch - Dispatches both asynchronous and synchronous downstream service calls within a single two-phase message transaction.
• Outbox Pattern Implementations - Implements a reliable outbox pattern to manage event-driven communication between services.
• Stale Request Blocking - Prevents inconsistent states by blocking late-arriving forward operations that occur after a transaction has already rolled back.
• Synchronous Transaction Awaiting - Blocks the caller until all downstream services in a transaction finish to coordinate business logic requiring immediate confirmation.
• Transactional Outbox Patterns - Guarantees reliable event publishing by recording messages in a local database before dispatching them to downstream services.
• Stale Request Blocking - Detects and blocks stale or out-of-order requests that could cause inconsistent state in a distributed transaction.

Historique des stars