eigr/spawn

This system is a distributed actor framework for building stateful, durable applications on Kubernetes. It provides a complete runtime for managing actor lifecycles, state persistence, and cross-node communication via NATS and gRPC. The platform includes a Kubernetes operator for automated resource management, an Elixir SDK for developer integration, and a CLI tool for local development and deployment.

56 changes.

This period established the foundational architecture of the Spawn project by organizing the codebase into a structured monorepo with distinct applications for the SDK, proxy, and Kubernetes operator. It introduced the core Elixir SDK for actor management, implemented state storage and distributed registry components, and set up the initial test coverage and configuration for the new system.

55 changes.

The period focused on expanding the platform's infrastructure by introducing Kubernetes resource generation, gRPC sidecar capabilities, and diverse state store adapters for PostgreSQL, MariaDB, and Mnesia. It also established core cluster coordination, security (ACL, TLS), and CLI tooling to support a multi-language SDK and local development environments.

6 changes.

This period focused on expanding the project's operational and development infrastructure, introducing new tools for containerized execution, local development environments, and process monitoring. It also addressed missing protocol buffer definitions and established a plugin architecture for the Kubernetes operator, alongside comprehensive observability configurations.

A new module has been introduced to generate CertManager Certificate resources for securing Erlang Dist TLS connections. This addition allows the system to automatically create Certificate resources that reference a specified Issuer or ClusterIssuer, enabling automated TLS certificate management for cluster communication.

_spawn\_operator/spawn\_operator/lib/spawn\operator/k8s/system/secret/certmanager · high confidence

Introduced new Ecto schema definitions for the statestore layer, including \HistoricalSnapshot\, \Lookup\, \Projection\, \Snapshot\, and a \ValueObjectSchema\ macro. These schemas define the structure for storing historical snapshots, node/actor lookups, projections, and value objects, enabling the Postgres statestore adapter to persist and retrieve clustered actor information and historical message data.

_spawn\statestores/statestores/lib/statestores/schemas · high confidence

A new HTTP interface module (\Actors.Actor.Interface.Http\) has been introduced to handle communication between the Proxy and the Host application. This module implements the \Actors.Actor.Interface\ protocol, providing logic to invoke host actors via HTTP requests. It supports invoking default actions when no specific action is provided, and handles response parsing and state updates for the actor.

lib/actors/actor/interface · high confidence

Introduces a new module, ActorSystemSecret, that generates a Kubernetes Secret containing environment variables for the actor system. This includes Erlang cluster configuration (cookie, polling, strategy, headless service) and state store database credentials (host, port, SSL settings). It also adds support for internal NATS broker connectivity, allowing the system to connect to a NATS cluster with optional TLS and authentication.

_spawn\_operator/spawn\_operator/lib/spawn\operator/k8s/system/secret · high confidence

Users can now store and query state using MariaDB. This adds MariaDB adapters for lookups, projections, and snapshots, enabling temporal data table support and dynamic table creation for projections.

_spawn\_statestores/statestores\mariadb · high confidence

The \statestores\_native\ module now provides a native statestore implementation backed by Mnesia, allowing users to persist actor state in an in-memory database. This change introduces the core adapter, test suite, and configuration to support Mnesia as a storage backend for the Spawn Actors System.

_spawn\_statestores/statestores\native · high confidence

A new \SpawnSdk.Channel.Subscriber\ module has been introduced to provide helper functions for subscribing and unsubscribing to Phoenix.PubSub channels. This enables the SDK to integrate with Phoenix's pub/sub system, allowing components to listen for and react to channel events via the \subscribe\ and \unsubscribe\ functions.

_spawn\_sdk/spawn\sdk/lib/channel · high confidence

The Postgres statestore implementation now includes dedicated adapters for managing actor snapshots, event projections, and lookup data. The snapshot adapter supports revisioning and historical tracking of state changes, while the projection adapter enables dynamic table creation and querying for Protobuf-based messages. Additionally, a new lookup adapter provides node-scoped data retrieval. These changes enable the Spawn Actors System to persist and query state in PostgreSQL, with corresponding test coverage for all three adapter types.

_spawn\_statestores/statestores\postgres · high confidence

The spawn\_sdk/spawn\_sdk\_example directory now contains a complete example project for the Spawn SDK. This includes a benchmark script (benchmark.exs) that measures performance for non-parallel and parallel invocations using the Benchee library, a code generation script (compile-example-pb.sh) for Protobuf/GRPC, and the core Elixir module (lib/spawn\_sdk\_example.ex) demonstrating actor invocation patterns such as synchronous, asynchronous, and pooled actor calls.

_spawn\_sdk/spawn\_sdk\example · high confidence

A new \spawnctl dev run\ command has been introduced to start the Spawn proxy in development mode. This command manages the local development environment, including the proxy, a NATS broker, and a local database, with configurable options for ports, image tags, and logging levels.

spawnctl/lib/spawnctl/commands/dev · high confidence

The Statestores.Migrator module has been introduced to handle database migrations via Ecto. It provides migrate and rollback functions that apply or revert schema changes for supported adapters, while explicitly excluding the NativeSnapshotAdapter and NativeLookupAdapter from these migrations.

_spawn\statestores/statestores/lib/statestores/migrator · high confidence

The sidecar now includes new Elixir modules in lib/sidecar/grpc/generators to automate the creation of gRPC client and server code for actors. Specifically, it adds an ActorInvoker generator that produces helper modules for invoking actor methods, a HandlerGenerator that creates server-side dispatchers for gRPC services, and a HandlerTranscodingGenerator that adds HTTP transcoding support. Additionally, a GRPCWithCustomOptions generator produces standard gRPC service and stub modules with custom method options, while a GeneratorAccumulator tracks registered services. These changes enable automatic generation of Elixir code that bridges gRPC calls to internal actor systems.

lib/sidecar/grpc/generators · high confidence

The SDK now includes generated Elixir modules for the Example service's protocol buffer definitions. This adds the \Example.EnumTest\ enum, the \Example.ValuePayload\ message (containing \value\, \id\, \enum\_test\, and \kind\ fields), and the \Example.ExampleState.Data\ message (containing \id\ and \test\ fields). These generated files enable type-safe serialization and deserialization of Example-specific data structures within the Spawn SDK.

_spawn\_sdk/spawn\_sdk\_example/lib/\generated/example · high confidence

New commands for configuring the Host application via ActorHost CRD and the ActorSystem via ActorSystem CRD have been added to the configuration module. These changes introduce the 'host' and 'system' subcommands, each with a placeholder implementation.

spawnctl/lib/spawnctl/commands/config · high confidence

A new plugin architecture is introduced for the Kubernetes operator, starting with a monitor plugin. The diff adds a \SpawnOperator.K8s.Plugins\ behavior module defining a \manifest\ callback, and a \Monitor\ plugin implementation that generates Kubernetes Service and Deployment manifests for monitoring. The monitor deployment includes specific environment variables, resource requests, and an init container for certificate management.

_spawn\_operator/spawn\_operator/lib/spawn\_operator/k8s/plugins, spawn\_operator/spawn\_operator/lib/spawn\operator/k8s/plugins/monitor · high confidence

Introduced three new adapter modules for native statestore operations: NativeLookupAdapter, NativeProjectionAdapter, and NativeSnapshotAdapter. The snapshot adapter implements actual Mnesia-based persistence for snapshots, while the lookup and projection adapters provide stub implementations that raise errors, indicating that lookup and projection features are not yet supported in the native backend.

_spawn\_statestores/statestores\native/lib/statestores/adapters · high confidence

Users can now use the 'spawnctl playground new' command to create and run a new Spawn playground. This new CLI command allows users to specify options such as name, namespace, recipe, timeout, and Kubernetes provider (k3d, kind, or minikube) to set up a local development environment. The command handles the installation of the selected Kubernetes distribution, deploys the Spawn operator, and applies the specified playground recipe, providing a streamlined way to spin up a complete development environment.

spawnctl/lib/spawnctl/commands/playground · high confidence

Introduces new modules for the daemon deployment mode: \Actors.Node.Client\ handles HTTP communication with actor hosts, supporting both sidecar and daemon configurations with a 60-second request timeout, while \Actors.Node.DefaultSplitBrainDetector\ implements network partition detection by verifying node status and host actor presence.

lib/actors/node · high confidence

Users can now create and manage local Kubernetes clusters using K3d, Kind, or Minikube. Each provider is implemented as a distinct module (k3d, kind, minikube) that implements a shared Installer behavior, allowing the playground feature to support multiple local cluster runtimes with consistent start, stop, and delete operations.

spawnctl/lib/spawnctl/commands/playground/k8s · high confidence

The lib/spawn/utils directory now includes three new modules: AnySerializer, which handles serialization of protobuf Any types to and from Elixir structures (including JSON); Common, which provides shared utilities like environment detection, actor host hashing, and supervisor logging; and Nats, which implements request and connection management for NATS pub/sub messaging, supporting both synchronous and asynchronous invocation requests.

lib/spawn/utils · high confidence

This change introduces a new CDC subsystem within the statestore controller, enabling the capture of database changes from PostgreSQL and publishing them to Kafka. The implementation includes a Postgres replication connection, a protocol handler for parsing binary log messages, and a message handler that filters and transforms transactions into Kafka events. The system is wired into the application supervisor, which conditionally starts the CDC supervisor when a Postgres snapshot adapter is detected, allowing users to stream database changes to downstream consumers via Kafka.

_spawn\_statestores/statestore\controller · high confidence

The scheduler now supports CronJob-based activation. A new \CronJob\ module generates Kubernetes CronJob resources that run a simple activator CLI container, pulling the image \eigr/spawn-activator-simple\ and configuring environment variables via a connection secret. A corresponding \Configmap\ module was also added to the scheduler activators directory.

_spawn\_operator/spawn\_operator/lib/spawn\operator/k8s/activators/scheduler · medium confidence

The project now includes the full set of Google Well-Known types (such as Any, Timestamp, Duration, Empty, Struct, and FieldMask) along with the Google API annotations (http.proto and annotations.proto). This ensures that all standard Protocol Buffers types and HTTP mapping rules are available at runtime, enabling seamless integration with gRPC-Web, REST API generation, and standard protobuf tooling without requiring external dependencies for these common types.

priv/protos/google · high confidence

The documentation for the MariaDB state store adapter has been added, including the API reference for the MariaDB lookup, projection, and snapshot adapters, as well as the necessary static assets and templates for the ExDoc-generated site.

_spawn\_statestores/statestores\mariadb/doc · high confidence

Added Kubernetes manifests for SPIFFE Service Provider Infrastructure Runtime Environment (SPIRE) to enable mTLS-based identity and authentication for workloads, including server and agent configurations, RBAC rules, and statefulset/daemonset definitions. Also added a MySQL deployment with a headless service and persistent volume claim for database storage.

k8s · high confidence

A new Elixir module, Actors.Security.Tls.Initializer, has been added to the codebase. This module provides a bootstrap\_tls function designed to be used as an initContainer in a Kubernetes environment. It interacts with the K8sConn and K8sWebhoox modules to ensure certificates are provisioned, logging success or failure appropriately.

lib/actors/security/tls · high confidence

Introduced three new Elixir behaviour modules—LookupBehaviour, ProjectionBehaviour, and SnapshotBehaviour—that define the standard interface for statestore adapters. These interfaces specify callbacks for retrieving clustered actor information, managing database projections, and handling snapshot storage, providing a consistent contract for implementing specific database adapters.

_spawn\statestores/statestores/lib/statestores/adapters · high confidence

A new customizer module was added to the \mix bonny.gen.manifest\ task, allowing users to override the default Kubernetes manifests generated by Bonny. Specifically, the \SpawnOperatorCustomizer\ modifies the generated Deployment to set the replica count to 2, configure liveness and readiness probes on port 9090, set resource limits and requests to 200m CPU and 380Mi memory, and add a volume mount for Bakeware cache. This enables users to customize the operator's deployment configuration directly from the code generation step.

_spawn\_operator/spawn\operator/lib/mix · high confidence

Introduced a new \DefaultAclManager\ module that implements the \Actors.Security.Acl\ behaviour. This component loads access control policies from \.policy\ files, parses them into \Policy\ structs, and evaluates authorisation by delegating to an \AclEvaluator\. The manager caches loaded policies in an Agent and provides a default allow-all policy if no custom policies are found, enabling the system to validate invocations against defined ACL rules.

lib/actors/security/acl · high confidence

New .proto files were added to define the ExampleActor and ProjectionActor services, establishing the data models and RPC interfaces for the example SDK. The ExampleActor is configured as a named, stateful actor with a Sum RPC, while the ProjectionActor is set up as a PROJECTION-type actor that maps to the ExampleState model and exposes query-based view endpoints (ExampleView and All) with specific retention and ordering configurations.

_spawn\_sdk/spawn\_sdk\example/priv · high confidence

The Spawn SDK example application was restructured to demonstrate core SDK capabilities. The new application entry point registers example actors (Joe, Example, Task, Json, Clock, Unnamed, PubSub, and Projection) with the Spawn system supervisor. Additionally, a Subscriber module was added to show how to listen to PubSub events outside of actors, specifically for integrations like Phoenix LiveView.

_spawn\_sdk/spawn\_sdk\_example/lib/spawn\_sdk\example · medium confidence

Two new exception types have been introduced to handle specific error conditions. NetworkPartitionException is raised when an actor is already active on another node, returning a 409 status. NotAuthorizedException is raised when an actor refuses to authorize a request, returning a 403 status.

_lib/\exceptions · medium confidence

The sidecar now supports graceful shutdown via a new \Sidecar.GracefulShutdown\ module that catches SIGTERM signals, enters a draining state, and delays the VM stop to allow in-flight requests to complete. Additionally, a new \Sidecar.MetricsSupervisor\ and \Sidecar.Measurements\ module were added to expose Prometheus-compatible metrics for the VM (e.g., memory, schedulers, run queues) and actor lifecycle (e.g., message queue length, duration), with an optional console log reporter.

lib/sidecar · high confidence

The application now exposes health check routes at /health, /health/liveness, and /health/readiness, each returning a 200 OK with a JSON payload {"status": "up"}. This is supported by a new router module that forwards requests to the health route handler, and a base route module that standardizes JSON response formatting and error code mapping for all route handlers.

_spawn\_operator/spawn\_operator/lib/spawn\_operator/router, spawn\_operator/spawn\_operator/lib/spawn\operator/routes · high confidence

The spawnctl directory now includes shell and PowerShell scripts (install.sh, install.ps1) that allow users to download and install the Spawn CLI binary for Linux, macOS, and Windows. The change also adds standard Elixir project configuration files (.formatter.exs, .gitignore, config files for dev/prod environments, and release templates) to support the CLI tool's build and runtime environment.

spawnctl · high confidence

Introduced new load balancing strategies for the distributed registry: a random selection strategy and a round-robin strategy that distributes load equally among nodes. These new modules implement the \Actors.Registry.LoadBalance.Strategy\ behavior, allowing the registry to locate actors using either random or round-robin algorithms.

_lib/actors/registry/load\balance · high confidence

The release environment now includes configuration files to enable TLS and mutual TLS (mTLS) for both server and client connections. New files define SSL options for local and general mTLS setups, including certificate paths and verification modes, while vm.args.eex is updated to enable TLS distribution and specify the mTLS configuration file. This allows the application to establish secure, encrypted connections out of the box.

rel · high confidence

The \spawnctl\ tool now includes distinct runtime behaviors for different environments. A new \K8sRuntime\ module handles the installation of the Spawn platform onto a Kubernetes cluster by downloading and applying a manifest file. Additionally, \UnixRuntime\ and \WindowsRuntime\ modules provide the logic for initializing new projects by downloading and extracting template archives. These changes introduce the core installation and project scaffolding workflows for each supported platform.

spawnctl/lib/spawnctl/runtimes · high confidence

Introduced new modules for managing the lifecycle of actor entity projections. The \StreamConsumer\ module handles message processing and batching for projection events, while \StreamInitiator\ manages the creation and configuration of NATS Jetstream streams and consumers, including support for replaying events and configuring retention strategies.

lib/actors/actor/entity/lifecycle · high confidence

A new Protobuf definition file (test.proto) was added to the statestores/priv/protos directory. This file introduces a TestMessage type that exercises a variety of field types and features, including scalar types (string, int32, double, bool, bytes), nested messages (Address), repeated fields (tags), map fields (attributes), and standard library types (Timestamp, Struct). It also includes custom options for actor ID and searchability, serving as a test case for the projection query DSL implementation.

_spawn\statestores/statestores/priv/protos · medium confidence

The SDK example library now includes a comprehensive set of actor implementations demonstrating various capabilities. This includes a clock actor with timers, an example actor for basic stateful operations, a JSON-based actor, a projection actor, a pub/sub actor for message broadcasting, a task actor, and an unnamed actor that triggers side effects. Additionally, the commit introduces the corresponding generated Protobuf/Erlang code for the associated services and message types, providing a complete reference for building actors with the Elixir SDK.

_spawn\_sdk/spawn\_sdk\_example/lib/spawn\_sdk\example/actors · high confidence

The operator now generates Kubernetes resources for each system, including a headless service for Erlang cluster connections, a dedicated namespace, a service account, and RBAC Role and RoleBinding to grant permissions for configmaps, secrets, and pods. This enables the operator to manage system-level infrastructure and permissions within each namespace.

_spawn\_operator/spawn\_operator/lib/spawn\operator/k8s/system · high confidence

A new internal\_versions.exs file has been added to the priv directory, establishing a single source of truth for the version numbers of all Spawn ecosystem packages (including spawn, spawn\_sdk, proxy, spawn\_operator, and various statestore implementations). This file drives the automated release process, ensuring that all related components are updated to the same version (currently 2.0.0-RC9) and are published together to Hex, simplifying the release workflow for developers.

priv · high confidence

The Elixir SDK now includes comprehensive documentation and code examples. The README.md provides installation instructions and usage guides for named, unnamed, and pooled actors, as well as side effects and pipe/forward routing. The Examples.cheatmd file offers detailed code snippets for various actor types and workflows. Additionally, .formatter.exs and .gitignore files are added to support the Elixir project structure.

_spawn\_sdk/spawn\sdk · high confidence

Added generated Elixir modules for the Spawn actors system, including the actor registry, extensions, health check, protocol status, and state definitions. These files provide the compiled Protobuf structures for actor kinds (such as named, pooled, proxy, task, and projection), actor options (including state management, snapshot intervals, and event ordering), health check status, and context metadata, enabling the application to interact with the Spawn actor framework via the generated protocol buffers.

_lib/\generated/spawn · high confidence

The SDK now generates Elixir service descriptors for \ExampleActor\ and \ProjectionActor\. The \ExampleActor\ is configured as a stateful, named actor with a 3000ms deactivation timeout. The \ProjectionActor\ is configured as a PROJECTION-type actor with a very long deactivation timeout (999,999,999ms), specific event retention strategies, and subject mappings to \ClockActor\. These generated files define the gRPC service interfaces and associated actor options that the SDK uses to manage actor lifecycle and state.

_spawn\_sdk/spawn\_sdk\_example/lib/\generated/actors · high confidence

The Spawn Operator is now configured with a default proxy image (ghcr.io/eigr/spawn-proxy:2.0.0-RC9) and standard Bonny/Kubernetes operator settings including the operator name, service account, and resource limits. This establishes the baseline environment-specific configurations (dev, prod, test) for the operator.

_spawn\_operator/spawn\operator/config · high confidence

The repository is initialized with a complete project structure, including a Makefile for build and test automation, a .tool-versions file specifying Erlang 27.2 and Elixir 1.18, and a compile-pb.sh script for generating protobuf code. The project also includes essential documentation and governance files such as a README, CONTRIBUTING guide, Code of Conduct, and a list of contributors.

(repo-wide) · high confidence

The Spawn operator is now available as a deployable Kubernetes operator, enabling users to manage custom resources such as ActorHost and Activator. The release includes the operator's deployment manifest, RBAC roles, and a configuration file for the proxy, establishing the foundational infrastructure for running EIRG-based applications on Kubernetes.

_spawn\_operator/spawn\operator · high confidence

The Spawn Operator is introduced, providing the core infrastructure for managing Eigr resources (Activator, ActorHost, and ActorSystem) within a Kubernetes cluster. This change establishes the application's entry point, a Kubernetes connection handler for development, test, and production environments, and the main operator definition that registers Custom Resource Definitions (CRDs) and their corresponding controllers. The operator is configured to watch all namespaces and utilizes a supervisor-based architecture to manage the lifecycle of these resources.

_spawn\_operator/spawn\_operator/lib/spawn\operator · high confidence

The SpawnMonitor application is introduced, providing a Phoenix-based web interface for monitoring spawned processes. This includes a health check endpoint, a LiveDashboard for metrics and request logging, and configuration for clustering via environment variables (supporting epmd, gossip, and Kubernetes DNS strategies). The release also includes standard project scaffolding such as formatters, gitignore rules, and initial test coverage.

_spawn\monitor · high confidence

The Statestores library is introduced as the core storage component for the Spawn Actors System. This change adds the foundational project structure, including the Apache 2.0 license, README with installation instructions for the \statestores\ package, and the main Elixir module (\Statestores\) that exposes the library's documentation.

_spawn\statestores/statestores · high confidence

A new \AclEvaluator\ module has been added to handle the core logic for evaluating Access Control List (ACL) policies against invocation requests. This component determines whether a request is allowed or denied based on the defined policy rules, supporting both allow and deny types with specific checks for actor names, systems, and actions.

lib/actors/security/acl/rules · high confidence

The Elixir SDK now includes a concrete implementation of the actor system, providing the \SpawnSystem\ and \Supervisor\ modules. This adds the capability to register actors, spawn them, and invoke actions with support for metadata, async calls, and pooled actors. The \Supervisor\ handles the startup and registration of the actor system, while \SpawnSystem\ manages the core logic for actor invocation and state management, bridging the gap between the SDK and the underlying actor framework.

_spawn\_sdk/spawn\sdk/lib/system · medium confidence

A new StateManager module has been added to provide a unified interface for the proxy to interact with databases. This module abstracts the underlying provider by delegating operations such as loading and saving snapshots, as well as creating, upserting, and querying projection tables through dedicated adapter methods.

_spawn\statestores/statestores/lib/statestores/manager · high confidence

Added new modules in lib/spawn/cluster/state\_handoff to manage clustered process state and invocation scheduling. The Manager coordinates node up/down events and delegates to a ControllerBehaviour, while the InvocationSchedulerState uses DeltaCrdt to maintain eventually consistent distributed state across the cluster. This enables reliable state handoff and global invocation scheduling in a clustered environment.

_lib/spawn/cluster/state\handoff · high confidence

The system now includes new modules for distributed cluster management: a distributed registry for tracking actor processes across nodes, a NATS-based server for handling cross-node invocations, and associated supervisors to manage these components. This enables actors to be discovered and invoked across the cluster via NATS messaging, with support for distributed process lookups and trace context propagation.

lib/spawn/cluster/node · high confidence

Added new Elixir modules (Children, CustomMnesiacSupervisor, SnapshotStore) that implement a native state store backed by Mnesia. The supervisor initializes Mnesia, dynamically setting the data directory based on the PROXY\_ACTOR\_SYSTEM\_NAME environment variable (using a temporary directory in non-production environments and /data/ in production), and creates a Mnesiac-backed snapshot store table with disc copies for persistence.

_spawn\_statestores/statestores\native/lib/statestores/adapters/native · high confidence

The Spawn framework now defines the core protocol for actor management, including the Actor model with support for NAMED, UNNAMED, POOLED, and PROJECTION actor types. The update adds proto definitions for actor state, snapshots, and health checks, while also introducing projection subjects and event retention strategies to support querying and mapping actions to actor states.

priv/protos/spawn · high confidence

The operator now includes dedicated handlers for three new Custom Resource Definitions: \ActorSystem\, \ActorHost\, and \Activator\. The \ActorSystem\ handler provisions the underlying cluster infrastructure, including namespaces, secrets, headless services, and RBAC roles. The \ActorHost\ handler manages the lifecycle of host applications, creating deployments, services, configmaps, and horizontal pod autoscalers. The \Activator\ handler processes events for \Activator\ resources. These handlers implement the \Pluggable\ behavior and register their respective Kubernetes resources as descendants of the corresponding CRD events.

_spawn\_operator/spawn\_operator/lib/spawn\operator/handler · high confidence

Added three new Elixir modules—Deployment, HPA, and Service—under the k8s/proxy path. These modules generate Kubernetes resources for the proxy: a Deployment with configurable replicas, resource requests (CPU, memory, ephemeral-storage), and optional mTLS init containers; a HorizontalPodAutoscaler that scales based on CPU and memory metrics; and a Service exposing the proxy HTTP port with Prometheus scrape annotations. The implementation supports environment variables, volume mounts, and affinity rules, enabling users to deploy and scale the proxy with standard Kubernetes features.

_spawn\_operator/spawn\_operator/lib/spawn\operator/k8s/proxy · high confidence

The diff introduces a new \Proxy\ application that serves as the entry point for the proxy service. It defines the application lifecycle, a root supervisor, and a Plug-based router that exposes HTTP endpoints for system management, actor spawning, and invocation, alongside health check and Prometheus metrics routes. The implementation supports both Unix domain sockets and TCP listeners, handles Protobuf and JSON parsing, and integrates with OpenTelemetry and Prometheus for observability.

_spawn\proxy/proxy · high confidence

The CLI now includes several new internal modules to support its operations. A new \Spawnctl.Cookiecutter\ module enables project generation by invoking the Python \cookiecutter\ tool, managing a Python virtual environment and executing the template. A \Spawnctl.GroupExecAfter\ GenServer provides a mechanism to schedule and execute callbacks after a specified delay. Kubernetes connectivity is handled by \Spawnctl.K8s.K8sConn\, which initializes connections for different environments (test, dev, prod) using \bonny\/\k8s\ libraries. Additionally, \Spawnctl.ReadmeFetcher\ allows the CLI to retrieve and display README files from GitHub repositories. Common utilities, including logging with emojis and file extraction, are consolidated in \Spawnctl.Util\.

spawnctl/lib/spawnctl · high confidence

The proxy component is now structured as a standalone application with its own configuration, environment variables, and test suite. Users can now configure the proxy's HTTP port, cluster strategy, and user function host/port via environment variables or config files. The proxy includes a symlink to shared protobuf definitions and a basic test suite to verify proxy functionality.

_spawn\proxy · high confidence

The \spawn\_initializer\ directory now contains a new Elixir library that provides an \initContainer\-compatible script for bootstrapping TLS certificates. The library includes an application module, a CLI entry point (\SpawnInitializer.main/1\), and a TLS initializer (\SpawnInitializer.Tls.Initializer\) that uses the \k8s\ library to fetch and manage certificates. This change adds the core implementation and associated unit tests for this new capability.

_spawn\initializer · high confidence

The operator now defines the v1 schema for the three core custom resources: ActorSystem, ActorHost, and Activator. The ActorSystem schema adds support for configuring cluster kind (erlang or quic), enabling features like mTLS and multi-cluster NATS transport, and specifying a state store (Native, MariaDB, or Postgres) with connection pooling. The ActorHost schema defines the structure for host applications, including autoscaling, volume mounts, and topology constraints. The Activator is registered as the storage version for the v1 API group.

_spawn\_operator/spawn\_operator/lib/spawn\operator/versions · high confidence

Added the core Actor Entity implementation, including the main GenServer (\entity.ex\), invocation handling (\invocation.ex\), lifecycle management (\lifecycle.ex\), state representation (\state.ex\), and supervisor (\supervisor.ex\). This change introduces the foundational structure for managing actor lifecycles, handling synchronous and asynchronous invocations, and managing actor state persistence and snapshots.

lib/actors/actor/entity · high confidence

The Actors module is introduced as the client API for managing Spawn actors, providing functions to register, spawn, and invoke actors, including a new invoke\_with\_nats function that routes requests via a NATS broker with OpenTelemetry tracing support. Additionally, the SplitBrainDetector behavior is added to define a contract for checking network partitions.

lib/actors · high confidence

A new \Actors.Config\ module has been added to centralize the management of system settings. This includes a \Name\ component for generating unique identifiers and a \PersistentTermConfig\ implementation that loads configuration values from environment variables and stores them in persistent terms. The configuration includes defaults for various system parameters, such as backpressure settings, gRPC ports, and database connections.

lib/actors/config · high confidence

The \SpawnOperator\ module now exposes a comprehensive set of default configuration values for the sidecar proxy and actor system, all of which can be overridden via Kubernetes resource annotations. Users can now explicitly configure the proxy image tags (e.g., \spawn-eigr.io/sidecar-image-tag\), HTTP client pool settings (schedulers, size, max idle timeout), NATS pub/sub connection details, CRDT sync intervals, and global backpressure parameters for actors. This change allows for fine-grained control over the spawned environment's networking, state synchronization, and performance characteristics without modifying the operator's core logic.

_spawn\_operator/spawn\operator/lib · high confidence

The statestores module now supports a native adapter alongside existing database adapters (Postgres, MariaDB), with the supervisor automatically loading the appropriate adapter based on configuration or environment variables. Additionally, the system now supports encrypted storage for sensitive data using the Cloak library, with new type definitions for binary and HMAC fields, and a dedicated Vault module for encryption configuration.

_spawn\statestores/statestores/lib/statestores · high confidence

The actor subsystem now includes a new \CallerProducer\ and \CallerConsumer\ pair to handle actor operations such as registration, spawning, and invocation via GenStage, enabling backpressure support. A new \InvocationScheduler\ GenServer manages scheduled and recurring actor invocations across the cluster. Additionally, the codebase introduces an \Interface\ module for host function calls, a \Pubsub\ module for actor event broadcasting, and a \StateManager\ with its corresponding behaviour definition to handle saving and loading actor state to persistent storage.

lib/actors/actor · high confidence

A new \Actors.Security.Acl\ module has been added to handle access control list logic. This module defines the structure for ACL policies, including names, types, actors, and actions, and provides callbacks for loading policies and checking authorization for invocation requests.

lib/actors/security · medium confidence

The spawnctl CLI now includes several new top-level commands: 'apply' for deploying Kubernetes resources, 'install' for setting up orchestrators like Kubernetes, 'new' for scaffolding new projects in multiple languages (Dart, Elixir, Go, Java, Node, Python, Rust), 'playground' for running a Spawn tutorial, 'config' for application configuration, and 'dev' for local development tasks.

spawnctl/lib/spawnctl/commands · high confidence

Added Dockerfiles for the Elixir-based services (example, initializer, operator, and proxy), each defining a multi-stage build using Elixir 1.15-alpine and a runtime stage based on Alpine Linux. A docker-compose.yaml was added to orchestrate local dependencies including OpenTelemetry, Zipkin, PostgreSQL, MySQL, MariaDB, and NATS. Additionally, observability configurations for Grafana, Tempo, and OTEL were introduced, alongside setup scripts for k3d and Kind clusters.

devops, guides · high confidence

The Elixir SDK introduces a new API for defining actors using \defact\ and \use SpawnSdk.Actor\, enabling actions to be declared as standard Elixir functions. The \SpawnSdk.Value\ struct now supports chaining methods to configure workflows, including \pipe\ and \forward\ for message routing, \broadcast\ for pub/sub, and \effect\ for asynchronous side effects. Additionally, the \Context\ struct carries state, caller, self, metadata, and tags, allowing actors to manage complex interactions and metadata.

_spawn\_sdk/spawn\sdk/lib · medium confidence

A new \sdk-init\ tool has been added to the \tools\ directory, providing a Go-based wrapper for running applications inside Docker containers. The utility copies protocol buffer files from a source directory to a shared directory at runtime and then executes the user's application. It includes signal handling to forward termination signals (SIGTERM, SIGINT) to the subprocess, ensuring graceful shutdowns in environments like Kubernetes. The package includes the main entry point, copier and runner logic, an example Flask application, and a Dockerfile for building the image.

tools · high confidence

The system introduces a new \ActorRegistry\ module that manages actor registration, lookup, and host selection. This includes a \HostActor\ struct to represent registered entities and a \LoadBalancer\ module that delegates host selection to a configurable strategy (defaulting to random). The registry supports filtering by parent or name and integrates with a state handoff mechanism for actor state management.

lib/actors/registry · high confidence

The system introduces a new cluster resolution strategy that discovers nodes via DNS or epmd, and a new supervisor hierarchy that manages cluster connections and task actor pools. For users, this means improved node discovery in Kubernetes environments using a headless service, and the ability to configure task actor pools with specific backend requirements (e.g., FLAME for remote execution). The \ClusterResolver\ handles node discovery, while \ClusterSupervisor\ orchestrates the cluster topology, and \ProvisionerPoolSupervisor\ manages the lifecycle of task actors, supporting both local and remote (Kubernetes) backends depending on the environment.

lib/spawn/cluster · high confidence

The sidecar now compiles Protobuf definitions to generate Elixir modules for gRPC services, enabling direct invocation of actors via gRPC. The dispatcher routes requests to actors, supporting unary, client, server, and bidirectional streaming. Additionally, the sidecar exposes health check endpoints (Readiness and Liveness) and supports gRPC reflection for service discovery.

lib/sidecar/grpc · high confidence

The \spawnctl new\ command now supports generating new projects for Dart, Go, Python, and Rust, in addition to the previously supported languages. Each new command includes standard project configuration options such as actor system name, application description, and statestore settings, providing a consistent interface for scaffolding new applications in these languages.

spawnctl/lib/spawnctl/commands/new · high confidence

The operator now generates a new ConfigMap named \<code\>sidecar\_configmap.ex\</code\> that constructs the Kubernetes ConfigMap for the Spawn proxy sidecar. This ConfigMap maps various annotations (such as HTTP client pool settings, NATS pub/sub configuration, CRDT sync intervals, and backpressure parameters) to environment variables, allowing users to configure the proxy's behavior, networking, and metrics through resource annotations.

_spawn\_operator/spawn\_operator/lib/spawn\operator/k8s/proxy/configmap · high confidence

Three new state handoff controllers have been introduced to manage distributed state across the cluster: CrdtController, which uses the DeltaCrdt library for eventually consistent replication; NatsKvController, which leverages the Nats Jetstream KV store for distributed state; and PersistentController, which utilizes a caching mechanism via Nebulex and a backend adapter for persistent storage. These controllers implement the ControllerBehaviour, enabling the system to handle node up/down events, clean up stale data, and synchronize state across nodes.

_lib/spawn/cluster/state\handoff/controllers · high confidence

Two new supervisor modules, \Actors.Supervisors.ActorSupervisor\ and \Actors.Supervisors.ProtocolSupervisor\, have been added to the codebase. The actor supervisor initializes a pool of consumers, manages invocation scheduling, and configures the pubsub adapter (supporting NATS). The protocol supervisor sets up a node registry and configures the HTTP client adapter (supporting Finch with configurable pool sizes and idle timeouts).

lib/actors/supervisors · high confidence

A new module, Actors.K8s.K8sConn, has been introduced to manage Kubernetes client connections. It provides environment-specific initialization: for dev and test environments, it loads a kubeconfig file with TLS verification skipped; for production, it attempts to load a kubeconfig file or falls back to a service account, also skipping TLS verification. This change alters how the application connects to Kubernetes clusters depending on the runtime environment.

lib/actors/k8s · high confidence

Users can now store state in MariaDB via the MariaDB statestore adapter. This includes a new 'lookups' table for the lookup adapter and a 'snapshots' table for the snapshot adapter. The snapshots table is configured with MariaDB's SYSTEM versioning, enabling temporal data tracking with automatic partitioning and retention limits. This change introduces the necessary database migrations to support these new storage capabilities.

_spawn\_statestores/statestores/priv/maria\_db\_snapshot\adapter · medium confidence

The Postgres state store adapter now includes a database migration that creates two new tables: \snapshots\ and \historical\_snapshots\. The \snapshots\ table stores current state with fields for actor, system, status, node, revision, tags, and binary data. The \historical\_snapshots\ table supports time-travel queries with \valid\_from\ and \valid\_to\ datetime columns, enabling the system to retrieve historical messages and state changes. This change provides the underlying storage infrastructure for the new historical message support in the Postgres adapter.

_spawn\_statestores/statestores/priv/postgres\_snapshot\adapter · high confidence

New certificate and key files have been added to the repository: a Certificate Authority (ca.crt/ca.key) and a TLS certificate (tls.crt/tls.key) for 'Operator Root CA' and 'Operator Admin Control Cert' respectively. These files provide the cryptographic material required for internal service authentication and encryption, likely supporting the 'init container' functionality mentioned in the commit message.

priv/certs · high confidence

A new Ecto migration has been added to create a 'lookups' table in the PostgreSQL database. This table stores lookup records with fields for id, node, actor, system, and data, along with appropriate indexes and a unique constraint on id and node.

_spawn\_statestores/statestores/priv/postgres\_lookup\adapter · high confidence

A new lookup cache module (Spawn.Cache.LookupCache) has been introduced, utilizing the Nebulex library with a partitioned adapter and a custom key generator. Additionally, the application's supervision tree has been restructured in Spawn.Supervisor, which now explicitly manages the lookup cache, cluster state handoff, and node connections, while conditionally starting internal Nats components based on configuration.

lib/spawn · high confidence

The application's configuration has been restructured into environment-specific files (dev, prod, test) with a shared base, allowing for distinct settings per environment. Additionally, OpenTelemetry is now integrated for distributed tracing, with the collector configured to export traces via OTLP to a local endpoint, and a dedicated OTel collector configuration file is provided to route traces to Zipkin and logging.

config · high confidence

A new default policy file has been introduced to the system, configured with an 'allow' type. This establishes a baseline permission setting for the application's access control logic, ensuring that the default state permits access unless explicitly restricted by other rules.

policies · high confidence

The \spawnctl\ tool now includes a new \playground\ command and a \custom\_build\_step\ module that allows users to execute a custom build step during the build process. The tool's version has been updated to 2.0.0-RC9, and the module structure has been adjusted to support these new capabilities.

spawnctl/lib · medium confidence

The install command for Kubernetes has been refactored to use a new \Runtime\ protocol defined in \SpawnCtl.Commands.Install.Behavior\. This protocol defines an \install\ interface that allows different installation strategies to be plugged in. The \Kubernetes\ command now delegates to this protocol, enabling more flexible and testable installation logic for Kubernetes operators.

spawnctl/lib/spawnctl/commands/install · high confidence

Added new modules to the cluster provisioner to support scheduled task execution. A new \SpawnTask\ struct and an \Executor\ protocol were introduced, with the \Scheduler\ module implementing the protocol to handle both synchronous and asynchronous invocations via the \FLAME\ library.

lib/spawn/cluster/provisioner · medium confidence

A new module, SpawnOperator.K8s.Manifest, has been added to define the interface for converting Kubernetes resources into manifest maps. This introduces a callback contract that accepts a resource and options, returning a manifest, which standardizes how Kubernetes objects are serialized or transformed within the operator.

_spawn\_operator/spawn\_operator/lib/spawn\operator/k8s · high confidence

The operator introduces three new controllers to manage specific Kubernetes resources: an ActivatorController for managing CronJobs, Jobs, Pods, Deployments, Services, ConfigMaps, Ingresses, and HorizontalPodAutoscalers; an ActorHostController for managing Nodes, Secrets, Pods, Deployments, Services, ConfigMaps, Ingresses, and HorizontalPodAutoscalers; and an ActorSystemController for managing RBAC roles, ServiceAccounts, Pods, Nodes, Deployments, Secrets, Services, ConfigMaps, and Cert-Manager certificates. Each controller defines its own RBAC rules to grant the necessary permissions for these resources. Additionally, a new Supervisor is introduced to manage the controller processes, ensuring that the application does not fail entirely if one controller encounters an error.

_spawn\_operator/spawn\_operator/lib/spawn\operator/controller · medium confidence

The K8s activators module has been refactored to support three distinct activator types: API, RabbitMQ, and Scheduler (CronJob). The \Activator\ module now routes requests to the appropriate handler based on the \activator.type\ field in the CRD spec. For API and RabbitMQ activators, the system now registers ConfigMaps, DaemonSets/Deployments, and Services. For Scheduler activators, the system registers CronJob resources. This change introduces new modules for each activator type and their respective Kubernetes resource manifests.

_spawn\_operator/spawn\_operator/lib/spawn\operator/k8s/activators · high confidence

The Spawn module's documentation has been significantly expanded to describe the actor-based runtime for building durable, stateful systems, including installation instructions, code generation steps, and a basic example. A new Sidecar module has been added to the lib directory.

lib · high confidence

The generated Elixir module for CloudEvents v1 (spec.pb.ex) was missing from the codebase. This change adds the generated protobuf definitions for CloudEvent and its attribute types, ensuring that the library can correctly serialize and deserialize CloudEvent messages according to the v1 specification.

_lib/\generated/io · high confidence

Add actor and serializer tests for the Elixir SDK; Add tests for actor host resource generation; Added initial test structure for Spawn SDK; Added initial test suite for the Spawn Operator; Added initial test suite for the spawnctl CLI tool; Added integration tests for the ActorHostController; Added test for actor registration across multiple nodes; Added test support files and example tests for the Spawn SDK; Added test support infrastructure for actor system testing; Added test support infrastructure for the Spawn Operator; Added test support infrastructure for the statestores module; Added tests for ACL evaluator policy rules; Added tests for MariaDB state store adapters; Added tests for actor registration, state retrieval, and health checks; Added tests for the Bonny manifest generator customizer; Test suite cleanup and configuration updates.

The project structure has been reorganized into a monorepo with new Elixir applications: \spawn\_initializer\, \spawn\_monitor\, and \spawn\_operator\. Each application includes its own \mix.exs\ and \mix.lock\ files, establishing the dependency graph for the respective components. The \spawn\_initializer\ depends on \k8s\ and \k8s\_webhoox\, the \spawn\_monitor\ integrates with Phoenix, Ecto, and Broadways, and the \spawn\_operator\ relies on \bonny\ and \flame\ for Kubernetes operator functionality. These changes reflect the split of the codebase into distinct, independently versioned applications within the unified repository.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 42 → 47 (+5.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 93 → 94 (+1.0)
• Architecture 77 → 85 (+8.8)
• Maturity 77 → 78 (+0.4)
• Readiness 26 → 32 (+5.3)
• Security 30 → 38 (+8.1)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — no supported dependency manifest was read
• Duplicated block (10 lines × 2) (spawn_sdk/spawn_sdk_example/lib/spawn_sdk_example/actors/example.pb.ex)
• Duplicated block (10 lines × 2) (spawn_sdk/spawn_sdk_example/lib/spawn_sdk_example/actors/example.pb.ex)
• Duplicated block (10 lines × 9) (lib/_generated/spawn/actors/healthcheck.pb.ex)
• Duplicated block (11 lines × 2) (lib/_generated/spawn/actors/healthcheck.pb.ex)
• Duplicated block (11 lines × 3) (lib/_generated/spawn/actors/healthcheck.pb.ex)
• Duplicated block (11 lines × 3) (spawnctl/lib/spawnctl/commands/new/elixir.ex)
• Duplicated block (12 lines × 2) (lib/sidecar/grpc/generators/handler_generator.ex)
• Duplicated block (12 lines × 2) (spawn_sdk/spawn_sdk_example/lib/_generated/actors/example.pb.ex)
• Duplicated block (12 lines × 2) (spawn_statestores/statestores_mariadb/lib/statestores/adapters/mariadb_projection_adapter.ex)
• Duplicated block (12 lines × 4) (lib/_generated/spawn/actors/healthcheck.pb.ex)
• Duplicated block (12 lines × 8) (lib/_generated/spawn/actors/healthcheck.pb.ex)
• Duplicated block (13 lines × 2) (spawn_operator/spawn_operator/lib/spawn_operator/k8s/activators/api.ex)
• Duplicated block (13 lines × 2) (spawn_operator/spawn_operator/lib/spawn_operator/k8s/proxy/deployment.ex)
• Duplicated block (13 lines × 5) (lib/_generated/spawn/actors/healthcheck.pb.ex)
• Duplicated block (13 lines × 9) (lib/_generated/spawn/actors/healthcheck.pb.ex)
• Duplicated block (14 lines × 3) (spawnctl/lib/spawnctl/commands/new/elixir.ex)
• Duplicated block (15 lines × 10) (lib/_generated/spawn/actors/actor.pb.ex)
• Duplicated block (15 lines × 15) (lib/_generated/spawn/actors/actor.pb.ex)
• …and 128 more

• Boundary-crossing change coupling: caller_consumer.ex ↔ customizer.ex (lib/actors/actor/caller_consumer.ex)
• Boundary-crossing change coupling: caller_consumer.ex ↔ mix.exs (lib/actors/actor/caller_consumer.ex)
• Boundary-crossing change coupling: http.ex ↔ spawn_system.ex (lib/actors/actor/interface/http.ex)
• Boundary-crossing change coupling: initializer.ex ↔ customizer.ex (lib/actors/security/tls/initializer.ex)
• Boundary-crossing change coupling: initializer.ex ↔ customizer.ex (spawn_initializer/lib/spawn_initializer/tls/initializer.ex)
• Boundary-crossing change coupling: initializer.ex ↔ deployment.ex (lib/actors/security/tls/initializer.ex)
• Boundary-crossing change coupling: initializer.ex ↔ internal_versions.exs (lib/actors/security/tls/initializer.ex)
• Boundary-crossing change coupling: initializer.ex ↔ mix.exs (lib/actors/security/tls/initializer.ex)
• Boundary-crossing change coupling: internal_versions.exs ↔ actor_host_handler.ex (priv/internal_versions.exs)
• Boundary-crossing change coupling: internal_versions.exs ↔ config.exs (priv/internal_versions.exs)
• Boundary-crossing change coupling: internal_versions.exs ↔ customizer.ex (priv/internal_versions.exs)
• Boundary-crossing change coupling: internal_versions.exs ↔ mix.exs (priv/internal_versions.exs)
• Boundary-crossing change coupling: internal_versions.exs ↔ sidecar_configmap.ex (priv/internal_versions.exs)
• Boundary-crossing change coupling: internal_versions.exs ↔ spawn_operator.ex (priv/internal_versions.exs)
• Boundary-crossing change coupling: mix.exs ↔ actor_host_handler.ex (spawn_initializer/mix.exs)
• Boundary-crossing change coupling: mix.exs ↔ config.exs (spawn_initializer/mix.exs)
• Boundary-crossing change coupling: mix.exs ↔ customizer.ex (spawn_initializer/mix.exs)
• Boundary-crossing change coupling: mix.exs ↔ deployment.ex (spawn_initializer/mix.exs)
• Boundary-crossing change coupling: mix.exs ↔ sidecar_configmap.ex (spawn_initializer/mix.exs)
• Boundary-crossing change coupling: mix.exs ↔ spawn_operator.ex (spawn_initializer/mix.exs)
• …and 441 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

eigr/spawn was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.