ServiceWeaver/weaver

Features

• Remote Procedure Calls - Implements a remote procedure call system to execute logic across distributed components using standard method calls.
• Distributed Application Frameworks - Framework for building scalable systems by organizing logic into independent components that communicate via remote procedure calls.
• Complex Data Serialization - Provides automated marshaling code for complex data structures and primitive types for network transmission.
• Component Replica Management - Distributes component instances across multiple machines and adjusts replica counts to match system load.
• Execution Environments - Provides an environment where distributed logic runs as a single unit locally or across cloud machines.
• Request Sharding - Distributes incoming requests among multiple component replicas to balance load and increase total throughput.
• Multi-Cluster Deployment Managers - Orchestrates application rollouts, regional load balancing, and container packaging across multiple Kubernetes clusters.
• Kubernetes Deployment Management - Manages the deployment state and regional rollouts of containerized binaries on Kubernetes clusters.
• Affinity-Based Routing - Implements routing keys to direct method calls to specific replicas, improving cache hit ratios and data locality.
• Contextual Metadata Propagation - Passes request-scoped key-value metadata through the execution context across process boundaries.
• Configuration-Driven Topology Mapping - Uses external files to define how components are grouped, placed, and networked across local and cloud environments.
• Distributed Application Building - Constructs applications as a set of components that run as a single unit locally or across multiple machines.
• Distributed Component Definitions - Organizes application logic into independent units that communicate without manual networking or serialization code.
• Automated Serialization Generation - Automatically produces serialization logic for complex data structures to ensure type-safe communication between remote processes.
• Process-Agnostic Execution - Allows the same logic to run as a local function call or a remote network request based on deployment configuration.
• Cloud Telemetry Suites - Provides an integrated suite for collecting and aggregating logs, metrics, and traces across distributed processes.
• Cloud Deployment Automation - Containerizes applications and manages incremental regional rollouts using canary clusters to reduce release risks.
• Multi-Environment Deployments - Transitions applications from local development to cloud production without altering the underlying business logic.
• Cloud Orchestration - Orchestrates the movement of applications into cloud environments using cluster management tools.
• Component Replica Sharding - Distributes incoming traffic across multiple component instances to balance load and increase system throughput.
• Kubernetes Deployments - Packages binaries into containers and provisions clusters, load balancers, and networking across multiple regions.
• Replica Sharding and Affinity - Manages component replica placement and routes requests via sharding or affinity to balance load and optimize performance.
• Component Affinity Routing - Directs method calls to specific component replicas using routing keys to optimize data locality and cache performance.
• Canary Version Rollouts - Manages incremental deployments by pinning client requests to specific versions to prevent cross-version incompatibility.
• Version Pinning Strategies - Ensures client requests stay within a single version during rolling updates to prevent cross-version communication errors.
• Local Cloud Simulation - Enables developers to run and debug distributed component logic on a local machine before deploying to the cloud.
• Process Colocation - Runs specific components within the same operating system process to eliminate network errors and reduce latency.
• Activity Execution Logs - Captures and filters logs using identifiers and key-value attributes to track individual component behavior.
• Application Metric Tracking - Collects counters and histograms for custom logic while monitoring method latency and throughput.
• Distributed Tracing - Exports request and method call traces to monitoring tools using OpenTelemetry standards.
• Distributed Logic Testing - Provides tools to verify that application logic behaves consistently whether running locally or across a distributed cloud environment.
• Distributed Profile Aggregation - Aggregates performance profiles from multiple processes and machines into a single unified view.
• Dependency Mocking - Replaces real logic with fake versions during testing to isolate and control external dependencies.
• Distributed Systems Testing - Verifies application logic through local debugging and remote execution modes using component mocks.
• Microservices - Microservice framework.

Star history