kestra-io/kestra
46.3
Weak · 24 October 2026
204.4k
lines of production code
Java
with TypeScript
4
measurements over time
What this system is
Kestra is a workflow orchestration platform that manages the definition, scheduling, and execution of complex, modular flows. It provides a comprehensive API and CLI for controlling distributed worker execution, managing state through pluggable storage backends, and handling dependencies between subflows. The system supports integration with external systems via HTTP and storage operations, while offering built-in capabilities for monitoring, logging, metrics, and dashboard visualizations.
How it got here
2019–2021 — Core architecture overhaul and CLI expansion
72 changes.
This period involved a fundamental restructuring of the Kestra platform, replacing the initial in-memory execution engine with a modular, pluggable architecture featuring abstracted queues, repository interfaces, and robust concurrency controls. The work significantly expanded the CLI with granular server management, plugin handling, and flow testing capabilities, while simultaneously enhancing the core with advanced metrics, secure storage, and a refactored Pebble template engine.
2022–2024 — Core infrastructure and plugin expansion
89 changes.
This period focused on establishing robust backend foundations by implementing multi-database support (PostgreSQL, MySQL, H2) and enhancing cluster reliability through refined service lifecycle and retry mechanisms. It simultaneously expanded the platform's capabilities by introducing a comprehensive suite of new core plugins, including a Key-Value store, custom dashboards, and advanced flow control features like SLAs and dynamic templating.
2025–2026 — Core infrastructure and execution engine refactor
120 changes.
This period focused on a comprehensive architectural overhaul of Kestra's core execution engine, introducing a modular Executor v2, a vNode-based scheduler, and a gRPC-based worker system to improve concurrency and reliability. Significant foundational work was also completed to establish new capabilities for HTTP client abstraction, distributed locking, and a pluggable queue backend, alongside the initial release of Kubernetes deployment charts.
Features
Add AppBlockInterface and AppPluginInterface marker interfaces
Two new marker interfaces, AppBlockInterface and AppPluginInterface, have been added to the core app module to define top-level plugin types. AppBlockInterface is designed for deserialization via a custom PluginDeserializer and explicitly avoids Jackson type info annotations to ensure the registered deserializer is used, while AppPluginInterface uses standard Jackson CLASS-based type info for polymorphic handling. Both interfaces enforce validation constraints on the 'type' field using specific regex patterns and schema annotations.
core/src/main/java/io/kestra/core/app · high confidence
Add configurable basic authentication for Kestra endpoints
Users can now secure Kestra's management endpoints by enabling basic authentication via the \endpoints.all.basic-auth\ configuration property. This change introduces a new HTTP filter that validates credentials against the configured username and password, returning a 401 Unauthorized status for invalid or missing credentials. The implementation uses constant-time comparison for credentials to mitigate timing attacks, ensuring that invalid usernames cannot be distinguished from invalid passwords based on response time.
core/src/main/java/io/kestra/core/endpoints · high confidence
Add markdown source models for flow descriptions and text
New model classes (FlowDescription, Text, MarkdownSource) are introduced in the dashboard chart markdown sources package to support fetching flow descriptions and rendering custom markdown text in dashboards. FlowDescription includes flow ID and namespace fields, while Text allows specifying markdown content directly. These classes use Jackson polymorphic serialization and OpenAPI schema annotations for proper API documentation.
core/src/main/java/io/kestra/plugin/core/dashboard/chart/mardown · high confidence
Add namespace CLI command with KV subcommand
A new \namespace\ CLI command has been added to manage namespaces, specifically delegating to the \KvCommand\ for key-value store operations. This command implements \NoDatabaseCommandInterface\, meaning it operates without connecting to the database, and displays help information when invoked without arguments.
cli/src/main/java/io/kestra/cli/commands/namespaces · high confidence
Added JMH benchmark module for execution and utility performance testing
A new \jmh-benchmarks\ module has been added to the project, providing a dedicated location for performance benchmarks using OpenJDK JMH. This module includes benchmarks for the \Executions\ logic (specifically comparing old vs. new approaches for finding the last created task run) and for \MapUtils.merge\ operations. Users can now run all benchmarks via \./gradlew jmh\ or target specific ones, such as \MapUtilsBenchmark\, to measure performance characteristics.
jmh-benchmarks · high confidence
Added No-Op Cache implementation
A new NoopCache class has been introduced in the core cache module, implementing the Caffeine Cache interface with no-operation behavior. This allows the system to disable caching while maintaining a consistent cache interface, eliminating the need for conditional logic or if/else chains when caching is not required.
core/src/main/java/io/kestra/core/cache · high confidence
Added OpenTelemetry trace propagation for Executions and RunContexts
This change introduces four new classes in the trace propagation package to support OpenTelemetry distributed tracing. ExecutionTextMapGetter and ExecutionTextMapSetter enable reading and writing the 'traceparent' header on Execution objects, while RunContextTextMapGetter and RunContextTextMapSetter provide the same functionality for RunContext objects. These components allow trace context to be correctly propagated across execution boundaries using the OpenTelemetry TextMapPropagator interface.
core/src/main/java/io/kestra/core/trace/propagation · high confidence
Added logging for retry events
A new listener class has been added to the core module that automatically logs details whenever a retry operation occurs. This includes the target class and method name, the current attempt number, and the overall delay, providing visibility into retry behavior for debugging and monitoring purposes.
core/src/main/java/io/kestra/core/listeners · high confidence
CLI startup hooks and local file-based flow synchronization
The CLI now executes a startup hook that initializes configuration-referenced plugins, saves the Kestra version and edition, and creates default MCP servers. Additionally, a new file-watching mechanism allows the CLI to automatically load, update, and delete flows from local YAML files, keeping the internal state synchronized with the filesystem.
cli/src/main/java/io/kestra/cli/services · high confidence
Executable JAR launch scripts and Gradle wrapper upgrade
Users can now run the application directly from the executable JAR using new \selfrun.sh\ (Linux/macOS) and \selfrun.bat\ (Windows) scripts, which handle plugin paths, configuration injection, and Java version checks (requiring Java 25+). These scripts also apply recommended JVM flags, including setting the maximum heap size to 50% of available memory, opening specific Java modules for library compatibility, and allowing unsafe memory access to suppress protobuf warnings. Additionally, the Gradle wrapper has been upgraded from version 5.1.1 to 9.8.0.
gradle · high confidence
Expanded internal metrics and centralized tag configuration
The metrics subsystem now exposes detailed operational data for the Worker, Executor, Scheduler, and Controller components, including thread counts, concurrency limits, job resubmissions, orphaned job reclaims, and SLA monitoring. A new GlobalTagsConfigurer automatically attaches a server\_type tag to all metrics, and the MetricConfig class allows users to define custom metric prefixes, global tags, and specific label keys to include in the output.
core/src/main/java/io/kestra/core/metrics · high confidence
Flowable tasks now support \`errors\` and \`finally\` blocks
The core flow control tasks—\If\, \Parallel\, \Dag\, \Loop\, \LoopUntil\, and \AllowFailure\—now support \errors\ and \finally\ blocks. The \errors\ block allows you to define tasks that run when a child task fails, while the \finally\ block ensures tasks run regardless of the outcome. This provides more robust error handling and cleanup capabilities within your workflows.
core/src/main/java/io/kestra/plugin/core/flow · high confidence
In-repo OSS JS/TS SDK with dev-time drift detection
The UI now ships an in-repo, generated JavaScript/TypeScript SDK (\@kestra-io/kestra-sdk\) for the OSS API, generated from the backend's OpenAPI spec using \@hey-api/openapi-ts\. The generated code is committed to git, decoupling the frontend build from the Java toolchain. A new dev-time staleness check warns developers if the committed SDK drifts from the backend's live OpenAPI spec, ensuring the client stays in sync without requiring manual regeneration for every change.
ui/packages/kestra-sdk · high confidence
Initial MySQL JDBC repository and queue implementation
This change introduces the first complete implementation of the MySQL JDBC backend for Kestra, enabling MySQL as a supported database for both the core data repository and the message queue. It adds MySQL-specific repository classes for all core entities (flows, executions, triggers, logs, metrics, settings, etc.) along with a generic \MysqlRepository\ base that handles MySQL-specific SQL dialects, such as full-text search using \MATCH...AGAINST\ and date formatting. The update also includes the necessary migration scripts to initialize the schema and queue tables, as well as a dedicated \MysqlMigrationLock\ to safely coordinate database migrations in multi-node deployments.
jdbc-mysql · high confidence
Initial release of the Kestra Helm chart
This change introduces the Kestra Helm chart for the first time, providing a new way to deploy the Kestra orchestration platform on Kubernetes. The chart includes a new \Chart.yaml\, \values.yaml\, and templated templates, along with documentation in \README.md\ and a test configuration in \values-testing.yaml\. It supports configuring deployments, autoscaling, and application settings via standard Helm values.
charts/kestra · high confidence
Initial repository scaffolding and development environment setup
This change establishes the foundational structure for the Kestra project by adding essential configuration and documentation files. It introduces coding standards via \.editorconfig\ and \.gitattributes\, sets up automated spell-checking with \.codespellrc\, and provides developer guidelines in \AGENTS.md\ and \CLAUDE.md\. The repository now includes a \Makefile\ for local build and deployment, Dockerfiles for base and application images, and \docker-compose\ configurations for CI and development environments. Additionally, it adds the Apache 2.0 \LICENSE\, a \SECURITY.md\ for vulnerability reporting, and a \.gitpod.yml\ for cloud-based development.
(repo-wide) · high confidence
Introduce Check model with 'when' condition and configurable failure behaviors
Users can now define validation checks within flows using a new \Check\ model. This model uses a \when\ field for boolean conditions (evaluated strictly against \true\) and allows configuring how failures are handled via \Behavior\ (blocking execution, failing the execution, or creating a new execution) and how they appear in the UI via \Style\. The class also includes a deprecated setter for backward compatibility with the previous \condition\ property.
core/src/main/java/io/kestra/core/models/flows/check · high confidence
Introduce Docker entrypoint script and configuration directories
The Docker image now includes a dedicated entrypoint script at /app/kestra, ensuring the application starts correctly via a standard shell wrapper. Additionally, placeholder directories for configurations, plugins, and secrets have been added to the image structure to support future mounting and management of these resources.
docker · high confidence
Introduce H2 in-memory runner for local development and testing
This change introduces a new H2-based in-memory runner, allowing Kestra to operate without an external database for local development and testing. It includes a complete set of H2-specific JDBC repositories (for flows, executions, triggers, metrics, logs, and more), a dedicated H2 repository implementation with full-text search and date formatting, and migration scripts to initialize the schema and queue tables. This provides a lightweight, self-contained backend that eliminates the need for external database setup during development.
jdbc-h2 · high confidence
Introduce Model Context Protocol (MCP) server support in the webserver
The webserver now includes a complete implementation for the Model Context Protocol (MCP), enabling Kestra to act as an MCP server for AI agents. This change adds the necessary transport layer, session management, and a cluster-aware caching mechanism for MCP server instances. It also introduces a schema mapper that automatically converts Kestra flow inputs and outputs into MCP tool definitions, allowing AI models to interact with Kestra flows as executable tools. Access control is enforced via a dedicated service that determines which flows a caller can execute based on their scope, and the system listens for flow and cluster events to keep the exposed tool definitions in sync.
webserver · high confidence
Introduce Process task runner for local subprocess execution
A new Process task runner has been added to the core runner package, allowing tasks to execute commands as local subprocesses on the worker. This runner exposes the working directory and output directory (when enabled) via template variables and environment variables, supports input/output file handling, and utilizes virtual threads for log consumption to improve concurrency. It provides a platform-agnostic way to run shell commands or scripts directly on the host OS, with automatic cleanup of descendant processes if the worker is interrupted.
core/src/main/java/io/kestra/plugin/core/runner · high confidence
Introduce Queue v2 with new abstract queue implementations and polling subscribers
The queue module has been upgraded to version 2, introducing a new set of abstract base classes (AbstractBroadcastQueue, AbstractDispatchQueue, AbstractKeyedDispatchQueue, AbstractVNodeDispatchQueue) that define the core emit and subscriber patterns for different queue types. A new AbstractPollingSubscriber implementation allows queues to use a configurable polling mechanism with adaptive intervals (QueuePoller) instead of relying solely on push-based notifications. The system now tracks subscriber pause/resume states via MonitoredQueueSubscriber, exposing metrics for active subscribers, pauses, and resumes. Additionally, the new architecture supports ignoring specific queue messages by key via IgnoreExecutionService and includes a fail-fast mechanism for processing exceptions.
queue · high confidence
Introduce TemplatedTask for dynamic task execution
Users can now use the new TemplatedTask plugin to render a YAML task definition from a \spec\ using Pebble templates and execute it at runtime. This enables highly dynamic task definitions driven by inputs or previous outputs. The task validates that the rendered definition is a RunnableTask and explicitly prevents nested TemplatedTask instances to avoid infinite loops. Additionally, the implementation ensures correct classloader context during execution to support ServiceLoader lookups for resolved plugins.
core/src/main/java/io/kestra/plugin/core/templating · high confidence
Introduce bar chart configuration options
Added BarOption to define configuration for bar charts in custom dashboards, including settings for the data column, tooltip behavior, and legend display.
core/src/main/java/io/kestra/plugin/core/dashboard/chart/bars · high confidence
Introduce core Asset model and declaration infrastructure
This change introduces the foundational data models for the new Assets feature, defining how assets are represented, declared, and tracked within flows. The \Asset\ abstract class establishes the core structure (tenant, namespace, id, type, metadata) and implements merge logic to handle updates without overwriting existing data, while also enforcing validation patterns for IDs and namespaces. \AssetsDeclaration\ allows tasks to specify input and output assets along with an \assetFailureBehavior\ property to control how failures (e.g., lock conflicts) affect the task state. Supporting models like \AssetIdentifier\, \AssetLineage\, and \AssetUser\ provide the necessary context for tracking asset usage across executions and flows. Additionally, internal asset types (\Custom\, \External\) are defined to handle specific asset scenarios, with \External\ marked as internal to prevent user declaration.
core/src/main/java/io/kestra/core/models/assets · high confidence
Introduce core HTTP client abstraction and data models
This change introduces a new HTTP client abstraction layer within the core module, adding foundational data models such as HttpRequest, HttpResponse, HttpSseEvent, and HttpService. These classes provide a structured way to handle HTTP requests and responses, including support for multipart/form-data and binary bodies, SSE events, and safe URI handling. The addition of KestraMediaTypes also standardizes media type handling, including support for the non-standard YAML media type. This abstraction serves as the basis for improved HTTP task and trigger functionality.
core/src/main/java/io/kestra/core/http · high confidence
Introduce core data models and services for MCP server management
This change adds the foundational backend components for managing Model Context Protocol (MCP) servers, including the \McpServer\ and \McpSession\ data models, repository interfaces for persistence, and the \McpServerService\ which automatically provisions a default private server per tenant. It also introduces cluster event payloads and session events to support distributed state synchronization, enabling the system to track server configurations and active connections across nodes.
core/src/main/java/io/kestra/core/mcp · high confidence
Introduce core model classes for custom dashboard charts
Added the foundational model classes for the new custom dashboard chart system, including the abstract \Chart\ base class with ID and type validation, \DataChart\ and \DataChartKPI\ for specific chart types with data filtering, and configuration options like \LegendOption\ and \TooltipBehaviour\. These models define the structure and validation rules for chart definitions within the core application.
core/src/main/java/io/kestra/core/models/dashboards/charts · high confidence
Introduce custom dashboard data models and configuration
This change introduces the core data models for the new custom dashboard feature, including the Dashboard entity (with a built-in default sentinel), ChartOption, DataFilter, and TimeWindow. It adds support for configurable query timeouts per dashboard, defines aggregation types (AVG, MAX, MIN, SUM, COUNT), and establishes export formats (CSV, ION) alongside chart styling options (LINES, BARS, POINTS).
core/src/main/java/io/kestra/core/models/dashboards · high confidence
Introduce distributed lock mechanism for service coordination
Added a new distributed locking system in the core module to manage concurrent access across service instances. This includes a LockService that provides methods to execute tasks within exclusive locks (doInLock, callInLock) or attempt non-blocking acquisition (tryLock), along with a LockServiceResourceReleaser that automatically releases all locks held by a service instance when it becomes unreachable, preventing stale locks from blocking other services.
core/src/main/java/io/kestra/core/lock · high confidence
Introduce flow SLA (Service Level Agreement) model
Added a new SLA model in the core flow definitions, allowing users to define and enforce execution constraints. The implementation includes a base SLA class with support for MAX\_DURATION and EXECUTION\_ASSERTION types, along with configurable behaviors (FAIL, CANCEL, NONE). New interfaces (ExecutionChangedSLA, ExecutionMonitoringSLA) and supporting classes (SLAMonitor, Violation) enable tracking execution deadlines and reporting violations when SLAs are breached.
core/src/main/java/io/kestra/core/models/flows/sla · high confidence
Introduce flow topology models for dependency visualization
Added new domain models in the core topology package to represent flow relationships and graph structures. This includes FlowNode to identify flows by UID and tenant, FlowRelation to define connection types (FLOW\_TASK, FLOW\_TRIGGER, SUBFLOW\_FUNCTION), FlowTopology to model source-to-destination links, and FlowTopologyGraph to aggregate these into a visualizable graph structure. These classes provide the foundational data structures for analyzing and displaying flow dependencies.
core/src/main/java/io/kestra/core/models/topologies · high confidence
Introduce internal Key-Value store with metadata, expiration, and automatic purging
This change introduces the core implementation of the internal Key-Value store, providing a new \KVStore\ interface and \InternalKVStore\ that validates keys and serializes values (including \Duration\ support) using ION format. It adds \KVMetadata\ to support optional descriptions and expiration dates (TTL) for entries, and \StorageKVBackend\ to persist metadata in a state store and values in internal storage. Additionally, it includes a \KVPurgeCleaner\ that automatically deletes expired KV entries on a scheduled basis, ensuring data hygiene without manual intervention.
core/src/main/java/io/kestra/core/storages/kv · high confidence
Introduce lightweight Namespace model and interface
Added a new lightweight Namespace model and its corresponding interface in the core models package. The Namespace class provides a minimal representation of a namespace identified by a validated ID string, while the NamespaceInterface defines the contract for namespace entities, including a utility method to convert namespace strings into hierarchical tree structures. This change establishes the foundational data structures for namespace handling within the core system.
core/src/main/java/io/kestra/core/models/namespaces · high confidence
Introduce namespace file metadata state store and service
Added a new abstraction layer for namespace file metadata operations to support gRPC-based workers. The \NamespaceFileMetadataStateStore\ interface and its \DefaultNamespaceFileMetadataStateStore\ implementation provide worker-safe methods for finding, saving, and deleting file metadata, delegating to the repository on server-side instances. Additionally, the \NamespaceFileService\ was introduced to handle server-only operations that require direct repository access, such as paginated listing with advanced filters, version-aware queries, and hard-deleting (purging) files from both metadata and storage.
core/src/main/java/io/kestra/core/namespace · high confidence
Introduce new dashboard chart types
Users can now build custom dashboards using a new set of chart components: Bar, KPI, Markdown, Pie, Table, and TimeSeries. These classes define the structure, options, and validation for each visualization type, enabling users to display categorical comparisons, single-value indicators, proportional distributions, structured data tables, and time-based trends within their dashboards.
core/src/main/java/io/kestra/plugin/core/dashboard/chart · high confidence
Introduce shared @kestra-io/hey-api-plugin for unified SDK generation and runtime
The \ui/packages/hey-api-plugin\ package consolidates the previously copy-pasted SDK generator logic into a single source of truth for the OSS UI, EE UI, and external \client-sdk\. It provides a codegen plugin that standardizes SDK method names (e.g., stripping \get\ prefixes) and patches the OpenAPI spec to fix YAML request-body content types and query filter serialization. The runtime entry point (\createConfigureClient\) replaces the hand-written client setup, providing a unified fetch-based client with RFC 9457 Problem Details error handling and specialized \EnterpriseFeatureError\/\SdkVersionMismatchError\ types to distinguish between missing Enterprise features and SDK/server version mismatches.
ui/packages/hey-api-plugin · high confidence
Introduce strongly-typed event identifiers and CRUD event model
The core events module now uses a new \EventId\ record based on UUIDv7, which provides time-ordered, lexicographically comparable identifiers for events, replacing previous ID mechanisms. Additionally, a new \CrudEvent\<T\>\ model and \CrudEventType\ enum have been introduced to standardize the representation of Create, Update, and Delete operations, including support for capturing the previous model state during updates and deletions.
core/src/main/java/io/kestra/core/events · high confidence
Introduce virtual node (VNode) based scheduler coordination
Added a new VNode coordination subsystem in the scheduler core that distributes trigger processing load across multiple scheduler instances using a consistent hashing ring. The new classes (VNodeConsistentHashRing, VNodeController, VNodesAssigner, and their implementations) enable automatic leader election, periodic rebalancing of vNode assignments when scheduler instances join or leave, and notification of assignment changes to subscribing services, ensuring deterministic and balanced trigger execution in clustered deployments.
core/src/main/java/io/kestra/core/scheduler/vnodes · high confidence
Introduces configurable table column alignment and table options for dashboards
The dashboard table component now supports explicit column alignment (left, right, or center) via the new TableColumnDescriptor, allowing users to control how data is visually aligned in table columns. Additionally, the new TableOption class exposes configuration for table-level features, specifically enabling or disabling the table header and pagination controls, which default to enabled.
core/src/main/java/io/kestra/plugin/core/dashboard/chart/tables · high confidence
Introduces tag-based Worker Queue routing and subscription model
This change adds a new Worker Queue system that allows routing jobs to specific worker groups based on tags. It introduces a subscription model where workers can subscribe to queues with reserved capacity percentages and modes (STRICT or ELASTIC) to control how reserved slots are shared. The implementation includes a metadata change handler for cache invalidation, a controller interface for managing worker nodes, and utilities for normalizing queue IDs and formatting logs. This enables more granular control over workload distribution across different worker types.
core/src/main/java/io/kestra/core/worker · high confidence
Introduction of ConditionContext for condition evaluation
A new ConditionContext class has been added to the conditions model package to encapsulate the context required for evaluating flow conditions. This context provides condition evaluators with access to the FlowInterface, the current Execution, the RunContext, and a mutable map of variables, enabling more robust and context-aware condition checks during flow execution.
core/src/main/java/io/kestra/core/models/conditions · high confidence
Introduction of RulePluginInterface for plugin-based governance policies
A new marker interface, RulePluginInterface, has been added to define the contract for plugin-based governance rules. This interface specifies that rule plugins must provide a type identifier that is a valid Java identifier, ensuring consistent identification for Enterprise Edition policy enforcement. The interface is explicitly designed to work with the custom PluginDeserializer, and the removal of @JsonTypeInfo ensures that deserialization is handled correctly by the registered serializer rather than being bypassed.
core/src/main/java/io/kestra/core/models/policies · high confidence
Introduction of TenantService for multi-tenancy support
A new TenantService has been added to the core module to handle tenant resolution and listing. Currently, this service is configured for the Open Source edition, where it always returns 'main' as the tenant identifier, effectively treating the system as single-tenant. This change lays the groundwork for Enterprise Edition multi-tenancy features by providing a standardized interface for tenant context, while maintaining backward compatibility for existing OSS users.
core/src/main/java/io/kestra/core/tenant · high confidence
Introduction of core asset management service and factory
The system now includes a new \AssetService\ interface and a corresponding \AssetManagerFactory\ within the core assets module. The service defines the contract for managing asset lifecycles, including asynchronous and synchronous upserts, lineage tracking, deletion, and the processing of task-run assets with specific failure behaviors. A no-op implementation is provided by default, allowing the feature to be opt-in or disabled, while the factory provides a mechanism to instantiate asset emitters based on an enabled flag.
core/src/main/java/io/kestra/core/assets · high confidence
Introduction of namespace-scoped purge task base contract
A new base interface, PurgeTask, has been added to define the contract for namespace-scoped purge operations. This interface extends SystemTask to ensure access to internal Kestra services required for resolving namespaces and enforcing access control. It introduces configurable properties for specifying target namespaces (via explicit list or pattern), options to include child namespaces, and a filter pattern to refine which items within those namespaces are selected for purging. This change establishes the foundational logic for namespace resolution and filtering used by specific purge implementations.
core/src/main/java/io/kestra/plugin/core/purge · high confidence
Introduction of structured log record model and exporter interface
This change introduces a new foundational model for log handling within Kestra. It adds the \LogRecord\ class to represent structured log data (including resource, timestamp, severity, attributes, and body) and the \LogRecordMapper\ to convert existing \LogEntry\ objects into this new format. Additionally, it defines the abstract \LogExporter\ interface, which establishes the contract for plugins that export logs, requiring an ID, type, and a \sendLogs\ method that accepts a stream of \LogRecord\ objects. This provides the core infrastructure for future log shipping and export features.
core/src/main/java/io/kestra/core/models/tasks/logs · high confidence
KV Store entries now support typed values and persistent metadata
The KV Store now enforces specific data types (STRING, NUMBER, BOOLEAN, DATETIME, DATE, DURATION, JSON) via the new KVType enum, allowing the system to automatically infer and store the type of a value when it is set. Additionally, each KV entry now maintains persistent metadata (PersistedKvMetadata) that tracks the revision number, description, expiration date, and soft-deletion status, ensuring that versioning and lifecycle management are handled consistently within the repository.
core/src/main/java/io/kestra/core/models/kv · high confidence
Kestra Helm chart v2.0 migration with new architecture and validation
The Kestra Helm chart has been rewritten to support version 2.0, introducing a distributed architecture with separate components (standalone, webserver, executor, indexer, scheduler, controller) and gRPC worker-controller support. The chart now enforces strict validation via \checks.yaml\, rejecting legacy embedded dependencies (PostgreSQL, MinIO, Kafka, Elasticsearch) and requiring explicit configuration via \configurations.application\, \configmaps\, and \secrets\. Key behavioral changes include the removal of the unsupported \--worker-group\ flag, the ability to set \progressDeadlineSeconds\ on Deployments, and logic to prevent rendering the main Service when only worker groups are enabled. Helper templates now provide granular JVM options and active processor count calculations based on CPU limits.
charts/kestra/templates · high confidence
Namespace file metadata model with versioning and soft deletion
A new NamespaceFileMetadata model has been introduced to manage namespace file attributes, including tenant ID, namespace, path, size, and timestamps. The model supports versioned files through a 'revision' field (persisted as 'version' for backward compatibility) and implements soft deletion logic, allowing files to be flagged as deleted while preserving historical revisions. This change provides the underlying data structure for improved performance and version control of namespace files.
core/src/main/java/io/kestra/core/models/namespaces/files · high confidence
Namespace files now support versioning and metadata
The internal storage for namespace files has been refactored to introduce a metadata layer and file versioning. Users can now access file metadata (such as creation and modification times) via the new FileAttributes interface, and namespace files are stored with revision tracking (e.g., .v1, .v2), allowing for version-aware retrieval and management of namespace file content.
core/src/main/java/io/kestra/core/storages · high confidence
New CLI commands for configuration and plugin schema generation
Users can now generate JSON schemas for Kestra's configuration properties and installed plugins using the new \configuration-schema\ command, and generate a comprehensive plugin schema bundle (covering flows, tasks, triggers, and dashboards) using the new \plugins-schema\ command. These commands allow for better editor integration and validation by outputting schema definitions to local files.
cli/src/main/java/io/kestra/cli · high confidence
New CLI commands for database migration management
The CLI now includes a dedicated 'migrate' command group with subcommands to manage database schema changes. Users can run 'kestra migrate plan' to preview pending migration scripts (optionally printing the SQL) without applying them, 'kestra migrate run' to explicitly apply all pending migrations, 'kestra migrate repair' to fix checksums for already-applied scripts, and 'kestra migrate unlock' to force-release persistent migration locks. These commands operate in a minimal application context that excludes plugins and other beans to ensure safe, isolated database operations.
cli/src/main/java/io/kestra/cli/commands/migrations · high confidence
New CLI commands for flow management and testing
The CLI now includes a dedicated 'flow' subcommand with five new operations: 'test' runs a flow definition in an isolated, ephemeral environment (using an in-memory H2 database and local storage) to validate logic without affecting production; 'delete' removes a specific flow by namespace and ID; 'export' packages flows into a ZIP file, correctly scoping the output to the specified namespace and its children; 'dot' generates a DOT graph visualization from a flow file; and 'syncFromSource' updates all persisted flows to match their current source definitions, forcing an update even if no content change is detected.
cli/src/main/java/io/kestra/cli/commands/flows · high confidence
New CLI commands for managing KV Store keys
Users can now manage Key-Value store entries directly from the command line using the new \kv\ and \kv update\ commands. The \kv update\ command allows setting values for specific keys within a namespace, supporting various data types (string, number, boolean, datetime, date, duration, JSON) and options to specify expiration times or read values from files. This provides a convenient way to interact with the KV store without needing to use the API directly.
cli/src/main/java/io/kestra/cli/commands/namespaces/kv · high confidence
New CLI commands for plugin management and documentation
The CLI now includes a dedicated 'plugins' command group with subcommands to install, uninstall, list, search, and generate documentation for plugins. Users can install plugins from Maven repositories (including those with basic auth) using the 'install' command, which supports installing all available plugins or specific artifacts. The 'search' command allows querying available plugins via the API. The 'doc' command generates documentation files for installed plugins, with options to include core tasks, export icons, generate JSON schemas, and skip deprecated plugins. The 'list' command displays currently installed plugins, and 'uninstall' removes specified plugins.
cli/src/main/java/io/kestra/cli/commands/plugins · high confidence
New CLI commands for system maintenance: reindex and submit queued executions
A new \sys\ command group has been added to the CLI, providing two subcommands for system maintenance. The \reindex\ command allows administrators to reindex all flow records by reading them from the database and updating them, currently supporting only the 'flow' type. The \submit-queued-execution\ command enables the manual submission of all queued executions to the executor, specifically for JDBC-backed queues (Postgres, MySQL, H2), while explicitly noting that Kafka queues require a different EE command. These commands are designed to operate without a database connection for certain operations, as indicated by the \NoDatabaseCommandInterface\ implementation in the parent \SysCommand\.
cli/src/main/java/io/kestra/cli/commands/sys · high confidence
New CLI commands to validate and inspect configuration
The CLI now includes \kestra configs validate\ to check configuration validity on demand, reporting errors with clear formatting, and \kestra configs properties\ to display the current configuration state (including active environments and property sources) with values masked for security. These commands operate without requiring a database connection or loading external plugins, ensuring they work reliably in minimal environments like Docker images.
cli/src/main/java/io/kestra/cli/commands/configs · high confidence
New DefaultIndexer service for batch-processing queue data
The indexer module now includes a new DefaultIndexer service that asynchronously consumes and batch-indexes execution logs, metrics, and execution statistics from their respective queues. This service ensures that these data types are persisted to their corresponding repositories (LogDataStore, MetricRepository, and ExecutionStatisticsRepository) via batch operations, improving efficiency and reliability of data indexing within the system.
indexer · high confidence
New Figma-driven color palette and design tokens
The design system now generates its color palette and theme variables directly from a Figma export, replacing the previous hardcoded values. This introduces a comprehensive set of base colors (blue, gray-cool, gray-neutral, green, orange, primary, red, yellow) and maps them to semantic CSS variables (e.g., \--ks-bg-base\, \--ks-text-primary\) for both light and dark modes. The change ensures that UI colors are now synchronized with the design team's Figma files, providing a consistent and maintainable visual language across the application.
ui/packages/design-system · high confidence
New FlowTopologyService for computing flow dependency graphs
A new FlowTopologyService has been introduced to calculate and manage the dependency graph between flows. This service identifies relationships such as flow tasks, flow triggers, and subflow functions by analyzing parent-child connections across all flows. It provides methods to generate topology graphs for specific namespaces or general flow sets, enabling better visualization and understanding of flow dependencies within the system.
core/src/main/java/io/kestra/core/topologies · high confidence
New KV Store tasks: Get, Put, Set, Delete, GetKeys, and PurgeKV
The KV plugin now provides a complete set of tasks for managing key-value entries. You can read values with Get (which supports hierarchical lookup within the same namespace), write or update values with Put (which supports deep merging for maps and patching for JSON fields), and create or type-coerce values with Set (supporting STRING, NUMBER, BOOLEAN, DATETIME, DATE, DURATION, and JSON types). Deletion is handled by Delete, listing by GetKeys (with optional prefix filtering), and bulk cleanup by PurgeKV (which supports purging by expiration, version age, or key patterns across namespaces). All tasks enforce namespace ACLs and support dynamic namespace targeting.
core/src/main/java/io/kestra/plugin/core/kv · high confidence
New Kestra Starter Helm chart with local S3 emulator
The \charts/kestra-starter\ directory now contains a complete Helm chart for deploying a pre-configured Kestra instance. This chart bundles the Kestra application and a PostgreSQL database, and introduces a local S3-compatible storage emulator (VersityGW) to handle workflow storage without requiring an external cloud provider. It includes all necessary Kubernetes manifests (StatefulSet, Service, Secret) and configuration values to run the stack out-of-the-box.
charts/kestra-starter · high confidence
New Log and PurgeLogs tasks for emitting and managing logs
This change introduces two new core tasks in the \io.kestra.plugin.core.log\ package. The \Log\ task allows flows to emit custom log entries at a specified severity level (TRACE, DEBUG, INFO, WARN, ERROR), supporting both single strings and arrays of messages with variable interpolation. The \PurgeLogs\ task provides bulk deletion of execution and trigger logs based on filters such as namespace, flow ID, execution ID, log levels, and date ranges, with options to control whether execution or non-execution logs are purged and a \batchSize\ parameter for MySQL performance tuning.
core/src/main/java/io/kestra/plugin/core/log · high confidence
New OutputValues task to emit custom templated data
A new \OutputValues\ task has been added to the core output plugins, allowing users to surface intermediate data for downstream tasks or inspection. It accepts a map of values (strings, numbers, arrays, or JSON objects) containing template expressions, renders them against the current execution context, and exposes the result under \outputs.\<taskId\>.values\.
core/src/main/java/io/kestra/plugin/core/output · high confidence
New Pebble functions for date logic, file operations, encryption, and HTTP requests
This change introduces a suite of new Pebble template functions to the core runner. For date handling, it adds dayOfMonth(), dayOfWeek(), hourOfDay(), isDateBetween(), and isDayWeekInMonth() to simplify temporal expressions. File operations are enhanced with fileExists(), fileSize(), and fileURI() (supporting namespace files and local paths), alongside a refactored read() function that now supports reading from internal storage and parent executions. Security and data handling features include encrypt() and decrypt() for payload encryption, an env() function to access environment variables, and an http() function for making outbound HTTP requests. Additionally, the range() function is now bounded to prevent heap exhaustion, and utility functions like id() and fetchContext() are added.
core/src/main/java/io/kestra/core/runners/pebble/functions · high confidence
New Pebble template filters for data manipulation, hashing, and string processing
This update adds a comprehensive suite of new Pebble filters to the core engine, expanding the capabilities available in workflow templates. Users can now chunk lists, flatten nested structures, and extract distinct values. String processing is enhanced with filters for escaping characters (single, double, shell), regex matching/extraction/replacement, substring operations, slugification, and case conversion. Data transformation includes filters to convert strings to specific number types, extract map keys, and format dates (timestamp, date add). Security and integrity checks are supported via MD5, SHA-1, and SHA-512 hashing filters. Additionally, a JQ filter allows for powerful JSON querying, and utility filters like \className\ and \distinct\ provide introspection and deduplication.
core/src/main/java/io/kestra/core/runners/pebble/filters · high confidence
New Publish and PurgeMetrics tasks for custom metric management
Users can now explicitly publish custom metrics (counters, timers, etc.) from within a flow execution using the new Publish task, allowing downstream monitoring to capture execution-time signals. Additionally, a new PurgeMetrics task enables bulk deletion of stored metrics by namespace, flow, execution, or date range, offering a performant alternative to per-execution deletions and including batch-size configuration for MySQL environments.
core/src/main/java/io/kestra/plugin/core/metric · high confidence
New Quota model for flow execution limits
A new Quota model has been introduced to define execution constraints for flows. This model allows users to specify a time duration (minimum 1 minute), a numeric limit, and a behavior strategy (FAIL or CANCEL) to determine how the system should react when the quota is exceeded.
core/src/main/java/io/kestra/core/models/flows/quota · high confidence
New Return task for debugging and value inspection
A new Return task has been added to the core debug plugin package, allowing users to render templated strings and return the result for inspection or reuse in downstream tasks. The task logs the rendered value at the debug level and exposes metrics for the output length and execution duration, facilitating troubleshooting and payload generation within flows.
core/src/main/java/io/kestra/plugin/core/debug · high confidence
New TriggerStateStore interface for scheduler trigger management
A new \TriggerStateStore\ interface has been introduced in the scheduler store package to manage trigger states specifically for the scheduler. This interface defines methods for finding triggers eligible for scheduling based on time and virtual node constraints, retrieving all states for specific virtual nodes, and managing individual trigger states via save and delete operations. It also includes a read-only lookup by ID without ACL checks and an initialization hook for preloading caches, providing a dedicated contract for scheduler-side trigger state persistence and retrieval.
core/src/main/java/io/kestra/core/scheduler/store · high confidence
New UI model classes for plugin distribution and manifest handling
This change introduces a set of new Java records and an enum in the core UI models package to support plugin UI metadata. Specifically, it adds PluginDistribution to distinguish between OSS and Enterprise Edition plugin artifacts, PluginUiManifest to hold the overall plugin UI structure, PluginUiModule and PluginUiModuleWithGroup to define individual UI modules with their static info, styles, distribution, and source hash, and TaskWithVersion to track task class and version information. These models provide the underlying data structures for exposing plugin UI details and managing their distribution scope.
core/src/main/java/io/kestra/core/models/ui · high confidence
New annotations for executor-restricted beans and configurable method retries
The core module now includes two new annotations to refine runtime behavior and reliability. The new \@RequiresExecutor\ annotation restricts specific beans (such as cluster-global scheduled jobs like purges) to run only on Executor or Standalone server types, preventing duplicate execution across cluster nodes while allowing them to remain active in local or test environments. Additionally, the \@Retryable\ annotation provides a Micronaut-backed mechanism for adding retry logic to methods, allowing users to configure the number of attempts, delay, multiplier, and specific exception types via application properties.
core/src/main/java/io/kestra/core/annotations · high confidence
New anonymous usage reporting infrastructure
This change introduces a new core reporting framework in the \io.kestra.core.reporter\ package to handle anonymous usage data. It adds a \Reportable\ interface and \AbstractReportable\ base class to define event types (such as USAGE, SYSTEM\_INFORMATION, PLUGIN\_METRICS, SERVICE\_USAGE, and PLUGIN\USAGE) and their reporting schedules. A \ReportableRegistry\ manages these reporters, while a \ReportableScheduler\ triggers them on a configurable fixed delay (defaulting to every 5 minutes) to collect and send data. The \ServerEventSender\ constructs structured \ServerEvent\ payloads containing instance and version details, then posts them to a configurable reporting endpoint (defaulting to \https://api.kestra.io/v1/reports/server-events\). Configuration is centralized in \UsageReportConfig\, allowing users to enable/disable the feature, set the reporting URI, and adjust delays via \kestra.anonymous-usage-report.\\ properties.
core/src/main/java/io/kestra/core/reporter · high confidence
New artifact slot contracts for topology and asset UI components
The \slot-contracts\ package now defines the type contracts for new UI extension points: \topology-details\, \topology-task-modal\, \topology-task-drawer\, \execution-artifact\, and \asset-card-footer\. These slots allow plugins to inject custom content into the topology graph details, task modals/drawers, execution artifact tabs, and asset card footers. The contracts specify props such as task/execution data, fetch functions for outputs and metrics, and manifest schemas for layout hints (e.g., footer height). A new codegen script ensures the published TypeScript definitions are flat and clean for external consumers.
ui/packages/slot-contracts · high confidence
New async operation processing infrastructure
Added a new set of classes in the core async package to support tracking and streaming the results of asynchronous operations. This includes the \AsyncOperation\ marker interface for domain events, the \AsyncOperationProcessedEvent\ record to broadcast outcomes, and the \AsyncOperationService\ to emit these events. The \AsyncEventStreamingService\ provides a fan-out mechanism for controllers to subscribe to specific operation results, while \AsyncOperationsConfiguration\ introduces a configurable wait timeout (defaulting to 30 seconds) for these operations.
core/src/main/java/io/kestra/core/async · high confidence
New automated database migration system with distributed locking and checksum validation
Kestra now includes a new migration framework that automatically applies pending database schema changes at startup. This system introduces distributed locking to prevent concurrent migrations in multi-node deployments, tracks migration history and checksums to detect unauthorized script modifications, and provides CLI commands (migrate run, plan, repair, unlock) for manual control. The migration runner executes before other beans initialize, ensuring the database schema is ready for use, and includes special handling for upgrades from previous Flyway-based deployments.
core/src/main/java/io/kestra/core/migration · high confidence
New command-based execution control interface
The executor now uses a structured command system to manage execution lifecycles, introducing an \ExecutionCommand\ interface with specific types for creating, replaying, restarting, pausing, resuming, and updating execution states. This change enables more precise control over execution operations, including the ability to replay executions from specific task runs, force-run executions, and update labels or status through a unified command pattern.
core/src/main/java/io/kestra/core/executor/command · high confidence
New common task models for encrypted strings and fetch outputs
Added three new classes to the core task models: \EncryptedString\ for handling encrypted text values with automatic encryption via \RunContext\, \FetchOutput\ to standardize task outputs for fetched data (supporting row lists, single rows, storage URIs, and row counts), and \FetchType\ enum to define how data fetching behaves (STORE, FETCH, FETCH\_ONE, NONE). These provide foundational types for tasks that need to handle sensitive data or structured fetch results.
core/src/main/java/io/kestra/core/models/tasks/common · high confidence
New configuration properties for dashboards, storage, and system flows
This change introduces new configuration records in the core context to manage specific subsystem settings. For dashboards, it adds \kestra.dashboards.queryTimeout\ (default 30s) and \kestra.dashboards.maxQueryTimeout\ (default 5m) to limit how long chart queries can run, preventing excessive resource usage. Additionally, it defines configuration structures for storage (\kestra.storage.type\), repository (\kestra.repository.type\), system flows (\kestra.system-flows.namespace\, defaulting to 'system'), and general Kestra settings (\kestra.allocatedCpuCores\, \kestra.environment\), allowing users to customize these aspects via configuration properties.
core/src/main/java/io/kestra/core/contexts/configuration · high confidence
New core context utilities and bean factory for versioning, storage, and logging
This change introduces several new classes in the core context package to support runtime versioning, centralized bean creation, and configuration management. ApiClientVersionFilter adds an X-Kestra-Version header to internal API calls, enabling version-aware responses. KestraBeansFactory centralizes the creation of key services like PluginCatalogService, StorageInterface, and LogDataStoreInterface, including logic to restrict external log stores to Enterprise Edition. KestraContext provides a static utility for accessing runtime information such as server type, allocated CPU cores, version, and edition. MavenPluginRepositoryConfig defines the configuration structure for Maven plugin repositories with optional basic authentication.
core/src/main/java/io/kestra/core/contexts · high confidence
New core model interfaces and data structures for system capabilities
The core models package introduces several new interfaces and records that underpin system-level features: KillSwitch support via EvaluationType and KillSwitchService, maintenance mode status reporting through MaintenanceStatusResponse, and a generic AccessScope record for backend-agnostic access control. It also adds lifecycle hooks for worker jobs (WorkerJobLifecycle), source-code handling for resources (HasSource), unique entity identification (HasUID), plugin versioning (PluginVersioning), soft deletion (SoftDeletable), and event pausing (Pauseable). New data models include Label (now a record with system label constants and validation), QueryFilter (a tree-based filter with AND/OR logic and many operations), SearchResult/SourceMatch for source search, Setting for instance metadata, ServerType for service classification, TenantAndNamespace/TenantInterface for multi-tenancy, and FileMetas for storage metadata.
core/src/main/java/io/kestra/core/models · high confidence
New core service infrastructure for filtering, outputs, and execution streaming
This change introduces a suite of new services in the core module to support advanced filtering, externalized output storage, and robust execution streaming. The new AbstractFilterService provides a unified, extensible base for applying various filter operations (such as equality, containment, and regex) to queries, enabling consistent filtering across different data sources. AbstractOutputService and its implementations (TaskOutputService, ExecutionOutputService) manage the serialization and storage of task and execution outputs, deciding whether to store data inline or in internal storage based on size limits, thereby improving performance for large outputs. Additionally, the new ExecutionStreamingService implements a fan-out mechanism for SSE-based execution following, ensuring reliable event delivery to multiple subscribers without blocking the queue, while AsyncOperationWaiter encapsulates the pattern for waiting on asynchronous operations with proper timeout and registration handling.
core/src/main/java/io/kestra/core/services · high confidence
New dashboard data sources for Flows, Logs, Metrics, and Triggers
This change introduces new data source plugins for custom dashboards, allowing users to visualize Flows, Logs, Metrics, and Triggers in addition to the existing Executions data. The new \Flows\, \Logs\, \Metrics\, and \Triggers\ classes (along with their KPI variants) enable charts to display data from their respective repositories, with support for global dashboard filters such as namespace, flow ID, and date ranges.
core/src/main/java/io/kestra/plugin/core/dashboard/data · high confidence
New deserializers for Assets and generic Plugins
The core serialization layer now includes dedicated deserializers for Assets and generic Plugins. AssetDeserializer handles Asset objects by defaulting to External type when only an ID is provided, with Custom as a fallback. Jackson3PluginDeserializer and its base PluginDeserializer enable runtime resolution of plugin types from JSON by querying the PluginRegistry, supporting versioned identifiers and special handling for DataChart types. This allows the system to correctly deserialize plugin and asset definitions from JSON payloads, including HTTP request bodies via the Jackson 3 counterpart.
core/src/main/java/io/kestra/core/plugins/serdes · high confidence
New dev-tools scripts for plugin deployment and release management
Added several shell scripts to the dev-tools directory to streamline local development and release candidate workflows. The \copy-plugin.sh\ script automates building Kestra plugins via Gradle and copying the resulting JARs to a specified plugins directory, while the \rc-manual-utilities\ group provides GitHub CLI helpers to clear action caches, trigger release workflows on specific branches, restart builds, and run workflows across all plugin repositories. Additionally, \setup-worktree.sh\ facilitates setting up OSS worktrees by copying necessary application configuration files from the main repository.
dev-tools · high confidence
New execution SLA types: MaxDuration and ExecutionAssertion
Users can now define Service Level Agreements for flows using two new specific types. The MaxDurationSLA allows setting a maximum allowed execution time, triggering a violation if the execution exceeds this positive duration limit. The ExecutionAssertionSLA enables users to provide a custom assertion expression that is evaluated against the execution context; if the assertion evaluates to false, a violation is raised. These types implement the SLA interface to integrate into the flow execution monitoring and validation logic.
core/src/main/java/io/kestra/core/models/flows/sla/types · high confidence
New execution and log statistics models
The core models for tracking execution and log statistics have been introduced, providing the data structures for daily execution counts, execution counts by state, log levels, and task run metrics. This includes the \ExecutionStatistic\ record for emitting asynchronous statistic rows upon execution termination, \DailyExecutionStatistics\ for daily aggregations, and \TaskRunStatistic\ for accumulating task run duration and count data, enabling the system to track and report on execution performance and status.
core/src/main/java/io/kestra/core/models/executions/statistics · high confidence
New execution control and management tasks
This location introduces a suite of new core tasks for managing execution flow and state: Assert validates boolean conditions and fails the flow if they are falsy; Exit terminates the current execution with a specified state (SUCCESS, WARNING, FAILED, CANCELED, or KILLED); Fail intentionally ends the flow, optionally based on a condition; Labels adds or overwrites execution labels while rejecting system labels and empty values; PurgeExecutions deletes historical execution data (executions, logs, metrics, storage) in batches; SetVariables merges key-value pairs into execution variables with optional overwrite protection; and UnsetVariables removes specific variables, supporting nested keys and missing-key handling.
core/src/main/java/io/kestra/plugin/core/execution · high confidence
New gRPC-based worker implementation with pull-based job fetching
The worker module now uses a new gRPC-based architecture where workers pull jobs from the controller via a bidirectional streaming interface instead of direct queue subscriptions. This change introduces a new \AbstractWorker\ base class, a \WorkerJobFetcher\ for flow-controlled job intake, and a \GrpcStubFactory\ for managing gRPC connections. Workers now advertise their thread count and max concurrency to the controller, support maintenance mode by pausing job intake, and expose live capacity metrics. The implementation also includes a new \WorkerLogEntryEmitter\ to emit logs to an intra-worker queue, decoupling logging from the main execution path.
worker · high confidence
New gRPC-based worker-to-controller communication with flexible service discovery
The worker-controller module now implements a new gRPC-based communication channel between workers and the controller, replacing the previous mechanism. This change introduces a configurable service discovery system supporting three strategies: STATIC (explicit endpoint list), DNS (A-record resolution), and STORAGE (dynamic discovery via Kestra's internal storage where controllers self-register). The implementation includes a new DefaultController gRPC server, a GrpcChannelManager for client-side connection management, and configuration classes for gRPC settings, basic authentication, and retry policies. Key features include support for HTTP proxies, basic authentication for the gRPC channel, configurable retry policies for safe RPCs, and health check integration. The controller also exposes metrics for capacity planning and supports proto reflection for debugging.
worker-controller · high confidence
New interface for tracking and reclaiming worker job states
Added the \WorkerJobRunningStateStore\ interface to manage the lifecycle of worker jobs currently in a RUNNING state. This interface provides methods to save, delete, and query running jobs, including specific support for handling jobs held by inactive or dead workers (orphaned jobs) and ensuring safe deletion when jobs are resubmitted to different workers. This infrastructure supports the new worker implementation's ability to reclaim jobs from inactive workers and prevents task runs from remaining stuck in a SUBMITTED state.
core/src/main/java/io/kestra/core/executor · high confidence
New internal runner infrastructure and execution context capabilities
This change introduces a suite of new internal classes within the core runner package to support advanced execution management. It adds an ACL checking mechanism (AclChecker) for validating resource access, a display expression renderer (DisplayExpressionRenderer) for safely evaluating Pebble templates in UI contexts without side effects, and a KV metadata state store (DefaultKVMetadataStateStore) for managing key-value data. Additionally, it implements new execution lifecycle events (ExecutionResumed, ExecutionTerminatedNotifier), concurrency limit tracking (ConcurrencyLimit), and asset emission interfaces (AssetEmitter) to facilitate better state management, logging, and resource handling during flow execution.
core/src/main/java/io/kestra/core/runners · high confidence
New metric model classes for Counter, Gauge, and Timer tasks
This change introduces the core model classes for the new metrics system within flow tasks. It adds AbstractMetric as the base type and concrete implementations for CounterMetric, GaugeMetric, and TimerMetric. These classes allow users to define metrics with dynamic names, descriptions, and tags, and handle the conversion of these definitions into execution-time metric entries via the RunContext.
core/src/main/java/io/kestra/core/models/tasks/metrics · high confidence
New metric model classes for counters, gauges, timers, and aggregations
The execution metrics package now includes dedicated model classes for different metric types: Counter, Gauge, and Timer, each extending AbstractMetricEntry and providing specific registration logic for the underlying MetricRegistry (incrementing for counters and timers, setting values for gauges). Additionally, MetricAggregation and MetricAggregations classes have been added to support grouping and summarizing metric data points by name, value, and timestamp.
core/src/main/java/io/kestra/core/models/executions/metrics · high confidence
New namespace file management tasks: Upload, Download, Delete, and Purge
This change introduces a new set of tasks for managing files within Kestra's Namespace storage. Users can now upload files using glob patterns or file maps (UploadFiles), download files to the working directory (DownloadFiles), delete specific files and optionally clean up empty parent folders (DeleteFiles), and purge old file versions based on retention policies or dates (PurgeFiles). These tasks provide a comprehensive API for handling namespace assets directly within flows.
core/src/main/java/io/kestra/plugin/core/namespace · high confidence
New plugin extension points and factory infrastructure
The plugin system now supports new extensibility points and a unified factory pattern for plugin instantiation. New marker interfaces \AppBlockInterface\ and \AppPluginInterface\ define the contract for App-type plugins, while \AdditionalPlugin\ serves as the base for plugin-defined subtypes. A new \AbstractPluginInterfaceFactory\ centralizes the logic for resolving, deserializing, and validating plugin configurations by type, reducing duplication across specific factories. Additionally, \ApplicationContextInitializable\ allows plugins instantiated from configuration to receive runtime beans, and \Jackson3PluginModule\ registers deserializers for all supported plugin types (including the new App interfaces) to work with the Jackson 3 migration.
core/src/main/java/io/kestra/core/plugins · high confidence
New plugin metadata annotations and model interfaces
The model layer now includes a new Plugin interface and a suite of annotations (@Plugin, @PluginProperty, @Example, @Metric, @PluginSubGroup) that allow plugins to declare aliases, priority levels, internal status, beta status, and associated code examples or metrics. Plugin properties can now be marked as secrets, assigned to groups with ordering indices, and tagged with specific Monaco editor languages, enabling richer documentation, better UI grouping, and stricter validation for sensitive values.
model · high confidence
New plugin notification utilities for execution context data
The core now provides a new \ExecutionInterface\ and \ExecutionService\ within the plugin notifications package, enabling plugin authors to access structured execution data (such as duration, start/end dates, links, and custom fields) for both the current execution and executions triggered by flow triggers. This change introduces the necessary abstractions and service logic to render and expose execution context variables to notification plugins, supporting features like custom messages and fields.
core/src/main/java/io/kestra/core/plugins/notifications · high confidence
New scheduler event types for trigger lifecycle and backfill management
The scheduler now emits a comprehensive set of new event types to track trigger state changes and manage backfills. Users will see new events for trigger creation, updates, deletion, evaluation, and execution termination, as well as specific events for when a worker is lost or a trigger is received. Additionally, new command events allow for creating, deleting, and pausing/resuming backfills, as well as resetting or disabling/enabling triggers with optional missed-schedule recovery.
core/src/main/java/io/kestra/core/scheduler/events · high confidence
New scheduler implementation with vNode-based trigger scheduling
The scheduler module has been replaced with a new implementation that manages trigger scheduling using virtual nodes (vNodes) for distribution. The new system introduces a \DefaultScheduler\ that coordinates \TriggerSchedulingLoop\ instances to evaluate and schedule triggers, while a \TriggerSchedulerMonitor\ checks for locked triggers and reports blocked schedules. The \TriggerEventHandler\ manages trigger state transitions, including backfill operations and trigger updates, and the \TriggerScheduler\ handles the core logic for evaluating schedulable triggers and publishing execution results. The \SchedulerEndpoint\ provides visibility into the current scheduling state, showing which triggers are schedulable and their next evaluation dates.
scheduler · high confidence
New startup cleanup and graceful shutdown listeners for server services
The CLI now includes two new application listeners to improve server lifecycle management. On startup, if the \kestra.configurations.delete-files-on-start\ property is enabled, configuration files associated with property sources are automatically deleted. During shutdown, the server now performs a graceful teardown of registered services via the \ServiceRegistry\, ensuring that all services except the Controller are closed concurrently before the Controller is shut down last, which helps workers disconnect cleanly before the gRPC server stops.
cli/src/main/java/io/kestra/cli/listeners · high confidence
New storage utility tasks: Concat, Deduplicate, Delete, Filter, Purge, Reverse, Size, Split, and Write
The core storage plugin now includes a suite of new tasks for managing files within Kestra's internal storage. You can now concatenate multiple files into one (Concat), remove duplicate lines based on a key (DeduplicateItems), delete specific files (Delete), filter line-oriented files using Pebble expressions (FilterItems), and reverse file line order (Reverse). Additionally, new tasks allow writing content directly to storage (Write), checking file sizes (Size), splitting files by size, rows, partitions, or regex patterns (Split), and purging execution files either for the current run (PurgeCurrentExecutionFiles) or across namespaces by date (PurgeStorage).
core/src/main/java/io/kestra/plugin/core/storage · high confidence
New topology package with live duration tracking and graph export
The \ui/packages/topology\ package introduces a new topology visualization component (\Topology.vue\) built on Vue Flow, featuring a \Duration\ component that breaks down task run times into queued, running, and paused segments with a detailed state history popover. It includes a \useLongestTaskRunDuration\ composable to keep live durations ticking for active tasks and a \useScreenshot\ utility to export the entire graph as PNG or JPEG images, handling scaling and background compositing for large flows.
ui/packages/topology · high confidence
New typed input models with validation and dynamic options
The flow input model layer has been expanded with dedicated classes for new and enhanced input types, providing stricter validation and richer configuration options. New types include ArrayInput (with item type constraints), BoolInput, EmailInput (with regex validation), IonInput, JsonInput (with JSON Schema validation), ReusableInputsInput (an EE feature for referencing shared input blocks), SecretInput (with regex validation and timeout protection), URIInput, and YamlInput. Existing types have been significantly enhanced: SelectInput and MultiselectInput now support dynamic value generation via expressions, decoupled label/value pairs through the new ValueOption record, and an auto-select-first default behavior; FileInput now validates against a configurable list of allowed extensions; and IntInput, FloatInput, DateInput, DateTimeInput, DurationInput, and TimeInput all support min/max or after/before range constraints. Additionally, the FormInput class allows grouping related inputs into a nested structure.
core/src/main/java/io/kestra/core/models/flows/input · high confidence
New usage and system reporting capabilities
The system now includes new reporting modules that collect and transmit usage data for features, plugins, services, and system information. FeatureUsageReport gathers flow, execution, and metric usage data on an hourly basis for Executor and Standalone server types. PluginMetricReport tracks plugin task and trigger performance metrics hourly on Scheduler, Worker, and Standalone types. PluginUsageReport provides daily plugin usage statistics for Executor and Standalone types. ServiceUsageReport collects daily service instance usage data. SystemInformationReport provides daily system configuration, host, and startup information. These reports enhance observability by providing detailed insights into how the platform and its plugins are being utilized.
core/src/main/java/io/kestra/core/reporter/reports · high confidence
Optional OpenTelemetry tracing for Kestra executions
The core module now includes a new tracing subsystem that instruments Kestra executions and run contexts with OpenTelemetry spans. This feature is optional and disabled by default; when enabled, it propagates trace context across executions and attaches attributes such as namespace, flow ID, execution ID, and tenant ID to spans. The implementation provides a \Tracer\ interface with \DefaultTracer\ (for OpenTelemetry integration) and \NoopTracer\ (for disabled mode), managed via a \TracerFactory\ that respects configuration settings defined under \kestra.traces\.
core/src/main/java/io/kestra/core/trace · high confidence
Pluggable log data store backend selection
Users can now select the log storage backend via the \kestra.logs.type\ configuration property. The system introduces a factory (\LogDataStoreInterfaceFactory\) that resolves the chosen backend as a plugin, along with a configuration record (\LogsConfig\) to handle per-type settings. For the default OSS mode, a global access control implementation (\GlobalLogDataStoreAccessControl\) is provided, granting unrestricted access to logs without auditing, while the architecture allows Enterprise Edition to replace this with context-aware access control.
core/src/main/java/io/kestra/core/repositories/log · high confidence
PostgreSQL repository implementation for Kestra's data stores
This change introduces the complete PostgreSQL-specific repository layer for Kestra, enabling the system to store and query flows, executions, logs, metrics, triggers, and other internal state in a PostgreSQL database. It includes the core \PostgresRepository\ class for handling JSONB persistence and full-text search, along with specialized repositories for execution outputs, statistics, concurrency limits, KV metadata, locks, and MCP servers. The implementation also provides PostgreSQL-specific query services for filtering by labels, states, and log levels, as well as migration utilities for schema creation and advisory locking to ensure safe multi-node deployments.
jdbc-postgres · high confidence
Webhook triggers now support configurable body handling and multipart/form-data
Webhook triggers now include a \fetchType\ property that lets you choose how the request body is processed: \FETCH\ (default) exposes the body on \trigger.body\, \STORE\ streams large or binary payloads into internal storage and exposes a \trigger.uri\ instead, and \NONE\ discards the body. Additionally, \multipart/form-data\ requests are now supported, with file parts automatically stored in internal storage and exposed on \trigger.parts\, while non-file fields are available on \trigger.formFields\.
core/src/main/java/io/kestra/plugin/core/trigger · high confidence
Removals
Removal of CLI entry point class
The main CLI entry point class (App.java) has been removed from the core module. This eliminates the default command-line interface implementation that previously handled help output and command execution via Picocli.
cli/src/main/java/org · high confidence
Removal of core flow execution engine and supporting infrastructure
The core execution engine, including the \Executor\, \Worker\, and \ExecutionState\ runners, has been removed from the \core\ module. This change eliminates the in-memory queue-based execution model (using \LocalQueue\), the \LocalRepository\ for YAML-based flow storage, and the associated data models such as \Execution\, \TaskRun\, \Flow\, and \State\. Consequently, the system no longer supports running flows via the previous standalone runner architecture or parsing flow definitions from local YAML files within this module.
core/src/main/java/org · high confidence
Security
Secure password storage with bcrypt and constant-time comparison
The core utility package now includes AuthUtils, which replaces the previous SHA-512 password storage with a secure bcrypt-based scheme (bcrypt(sha512(salt\|password))) and provides constant-time credential comparison to prevent timing attacks. This change ensures that BasicAuth passwords are stored safely against offline dictionary attacks and that verification is resistant to timing side-channels.
core/src/main/java/io/kestra/core/utils · high confidence
Architecture
Executor v2: Refactored execution engine with modular concurrency and liveness coordination
The executor has been refactored into a new modular architecture (Executor v2) that introduces dedicated state stores for managing concurrency limits, execution delays, and execution locking, alongside a new service liveness coordinator. This change improves the reliability of concurrency enforcement by atomically releasing slots and popping queued executions, ensures execution delays (such as pauses and retries) are processed safely outside of state-store transactions, and centralizes service health monitoring to better handle worker job reclamation and vNode rebalancing.
executor · high confidence
Introduce dedicated scheduler model classes for trigger state and type
The scheduler now uses new \TriggerState\ and \TriggerType\ classes in the \io.kestra.core.scheduler.model\ package to manage trigger lifecycle and classification. \TriggerState\ serves as the immutable record of a trigger's current status, tracking evaluation dates, backfill progress, disabled states, and worker assignments, while \TriggerType\ explicitly categorizes triggers as SCHEDULE, POLLING, or REALTIME to support distinct handling logic within the scheduler.
core/src/main/java/io/kestra/core/scheduler/model · high confidence
Repository interfaces restructured for modular storage backends
The repository layer has been refactored to support pluggable storage backends (JDBC, Elasticsearch, and others) through a set of new, capability-focused interfaces. This introduces dedicated repositories for distinct concerns—such as \ExecutionOutputRepositoryInterface\ for storing execution outputs separately, \ExecutionStatisticsRepositoryInterface\ for pre-aggregated stats, and \LogDataStoreInterface\ with capability flags for purge support and pagination modes (offset vs. cursor). The core \ExecutionRepositoryInterface\ and \FlowRepositoryInterface\ now extend \DistinctFieldValuesQueryInterface\ to enable dynamic filter suggestions, while \NamespaceAccessControl\ centralizes ACL policy translation. Additionally, \LocalFlowRepositoryLoader\ provides a mechanism to load flows from local file paths or JAR resources, and \ArrayListTotal\ standardizes paginated responses with total counts across all repository implementations.
core/src/main/java/io/kestra/core/repositories · high confidence
Behavioural changes
3976 commits (1810 fixes) modifying ui
A change to existing behaviour in ui — 3976 commits (1810 fixs), 1504 files.
ui · medium confidence · unverified
Added ZIP-bomb protection and internal call context for security
Users can now enable protection against ZIP-bomb attacks via the \kestra.security.zip-bomb-protection\ configuration, which enforces limits on the number of entries and uncompressed size per entry during decompression. Additionally, an internal call context mechanism has been introduced to distinguish between user requests and internal server-to-server calls (such as worker gRPC calls), ensuring that row-level permission filters are applied correctly without inadvertently blocking internal operations.
core/src/main/java/io/kestra/core/security · high confidence
CLI namespace update defaults to no-delete and introduces no-database command interface
The namespace update command now defaults to not deleting missing files (the --delete flag is false by default), preventing accidental data loss during updates. Additionally, a new NoDatabaseCommandInterface has been introduced to allow CLI commands that do not require a database connection to run without initializing database beans, improving startup performance and resource usage for such commands.
cli/src/main/java/io/kestra/cli/commands · high confidence
CLI server commands are restructured into dedicated subcommands with new configuration options
The CLI server management is reorganized into a \server\ parent command with distinct subcommands for each component: \standalone\, \webserver\, \worker\, \executor\, \scheduler\, \indexer\, \controller\, and \local\. This change introduces granular control over server components, allowing users to start individual services (like the executor or indexer) independently. New command-line options have been added to the \standalone\ and \webserver\ commands to disable embedded components (\--no-indexer\, \--no-controller\) and to configure worker thread counts (\--worker-thread\). Additionally, the \standalone\ command now supports tenant creation via the \--tenant\ flag and flow preloading via \--flow-path\. The \local\ command is introduced to simplify local development by automatically configuring an H2 database and local storage.
cli/src/main/java/io/kestra/cli/commands/servers · high confidence
Centralized encryption configuration and service implementation
The encryption subsystem has been refactored to centralize access to the secret key via a new \EncryptionConfig\ singleton bean, which reads the key from the \kestra.encryption.secret-key\ property and supports optional configuration. The underlying \EncryptionService\ (renamed from \CryptoService\) now explicitly handles base64 decoding of the provided key and implements AES/GCM/NoPadding encryption/decryption, ensuring that null inputs are handled gracefully without crashing.
core/src/main/java/io/kestra/core/encryption · high confidence
Centralized validation framework with new constraint annotations
The application now uses a centralized validation framework in the core module, introducing a suite of new Jakarta Bean Validation constraint annotations (such as @FlowValidation, @InputValidation, @SafeRegexValidation, @Rfc1123Label, and @TenantId) to enforce stricter rules on flows, inputs, and configuration. This change adds validation for application URLs, server command properties, and worker-specific configurations, while also preventing security risks like ReDoS through safe regex checks and ensuring data integrity by restricting system labels and validating duration ranges.
core/src/main/java/io/kestra/core/validations · high confidence
Copilot v2 introduces an agentic conversation model with persistent threads and tool-based modes
The Copilot now uses a new agentic loop backed by persistent conversation threads and messages, enabling multi-turn interactions with history and tenant isolation. Users can interact in three modes—Ask (read-only), Plan (read and mutate artefacts), and Edit (read, mutate, and act)—which control the tools available to the AI. The system supports tool calls, reasoning state persistence for provider compatibility, and draft artefacts (flows, dashboards, apps, tests), with actions in Edit mode requiring user confirmation.
core/src/main/java/io/kestra/core/ai · high confidence
Custom Stackdriver JSON logging layout for CLI
The CLI now uses a custom StackdriverJsonLayout implementation to format log output, replacing the previous micronaut-gcp-logging dependency. This new layout extends Logback's JsonLayout to produce JSON logs compatible with Google Cloud Logging, including specific handling for severity, timestamps, and exception stack traces within the message body.
cli/src/main/java/io/kestra/cli/logger · high confidence
Enhanced serialization reliability and performance
The serialization layer now supports deserializing duration values from floating-point strings, ensuring that numeric duration inputs are handled correctly without errors. ION file processing has been optimized with streaming and binary formats, improving memory usage and read/write performance for large datasets. Additionally, flow labels can now accept non-string data types (such as integers, floats, and booleans), and the system provides more robust error reporting by scanning YAML sources to identify and report validation issues without failing the entire parse.
core/src/main/java/io/kestra/core/serializers · high confidence
Execution model refactored with new metadata, kill events, and metric entry types
The execution data model in core has been restructured to support richer execution tracking and more granular control. The Execution model now includes an ExecutionMetadata object that tracks concurrency scopes, execution depth, and task run statistics, alongside a new ExecutionKind enum to distinguish between normal, test, playground, and loop executions. Kill events have been split into specific types (ExecutionKilledExecution, ExecutionKilledTrigger, ExecutionKilledTaskRuns) to allow for targeted interruption of executions, triggers, or specific task runs. Additionally, a new AbstractMetricEntry hierarchy (Counter, Gauge, Timer) and MetricEntry model have been introduced to standardize how metrics are recorded and emitted for executions.
core/src/main/java/io/kestra/core/models/executions · high confidence
Expanded anonymous usage reporting with new collector models
The anonymous usage reporting system now collects a broader set of operational and configuration data to help improve the platform. New collector models in the core models package gather detailed insights: ConfigurationUsage captures infrastructure settings (repository, queue, storage, secret, and log types); ExecutionUsage provides daily execution statistics; FlowUsage aggregates flow counts, namespace counts, and usage of specific features like inputs, outputs, labels, variables, concurrency, retries, and SLAs; HostUsage reports server hardware, OS, and JVM details; MetricUsage tracks runtime metrics for executors, queues, workers, and the webserver; PluginUsage lists installed plugin manifests; and ServiceUsage monitors the number of running service instances over time. This expanded data collection allows the Kestra team to better understand how the system is deployed and used.
core/src/main/java/io/kestra/core/models/collectors · high confidence
Fix validation of tasks and triggers with dynamic properties
The application now correctly validates tasks and triggers that use dynamic properties. A custom Hibernate Validator factory provider replaces the default Micronaut provider to manually register the PropertyValueExtractor, resolving a conflict that previously prevented ValueExtractors from working and causing validation failures for dynamic property usage.
core/src/main/java/io/kestra/core/validations/factory · high confidence
HTTP plugin tasks rewritten to use a new Apache HttpClient abstraction
The core HTTP plugin tasks (Request, Download, SseRequest, Trigger) have been refactored to use a new internal HttpClient abstraction built on top of Apache HttpClient. This change introduces a unified HttpConfiguration for options (such as authentication and timeouts) and updates the underlying request/response handling logic. Users will see consistent behavior across HTTP tasks, including improved handling of form data, content encoding, and filename extraction from Content-Disposition headers, while maintaining the same task interfaces and configuration properties.
core/src/main/java/io/kestra/plugin/core/http · high confidence
Introduce dynamic Property and Data types for runtime rendering and structured data handling
The core property model has been replaced with a new dynamic system. The new Property class allows plugin inputs to be defined as either static values or Pebble expressions, deferring rendering and type conversion until execution time via the RunContext. This enables dynamic configuration for tasks like Pause (timeout/delay) and supports Pebble expressions in input defaults. Additionally, a new Data type has been added to handle structured data inputs, allowing users to pass maps, lists, URIs (including local and namespace files), or JSON strings, which are then streamed and converted to target types at runtime.
core/src/main/java/io/kestra/core/models/property · high confidence
Introduce new Apache HttpClient5 abstraction for HTTP tasks
The HTTP client implementation for Kestra tasks has been replaced with a new abstraction built on Apache HttpClient5. This change introduces explicit configuration for timeouts, proxy settings, and logging, while adding a security interceptor to validate URIs during redirects to prevent SSRF attacks. It also explicitly disables Brotli compression negotiation to avoid native library errors, supports digest authentication, and integrates Micrometer observability for tracing and metrics.
core/src/main/java/io/kestra/core/http/client · high confidence
Introduces a new, abstracted queue interface hierarchy
The core queue system has been refactored to use a new set of interfaces that separate message delivery semantics. A base \GenericQueueInterface\ handles basic listeners, while specialized interfaces now define specific behaviors: \BroadcastQueueInterface\ for emitting events to all subscribers, \DispatchQueueInterface\ for standard dispatching, \KeyedDispatchQueueInterface\ for routing messages via routing keys, and \VNodeDispatchQueueInterface\ for virtual-node-based dispatching. This change also introduces a \QueueSubscriber\ interface with explicit pause/resume capabilities and a \QueueService\ to standardize key generation for queue messages.
core/src/main/java/io/kestra/core/queues · high confidence
Ion serialization now uses binary format with precise Java date/time handling
The ION serializer has been replaced with a custom implementation that writes data in binary format for better performance and introduces dedicated serializers for Java date and time types (Instant, LocalDate, LocalDateTime, OffsetDateTime, ZonedDateTime, OffsetTime, LocalTime). This ensures these types are correctly serialized and deserialized using ION's native timestamp capabilities rather than generic string representations, improving data fidelity and storage efficiency.
core/src/main/java/io/kestra/core/serializers/ion · high confidence
JDBC backend infrastructure and reliability improvements
The JDBC module introduces a centralized repository base class (AbstractJdbcRepository) and factory-based table configuration to standardize database access. It adds a dedicated datasource provider for logs, allowing them to be stored in a separate database. To improve reliability, the system now automatically retries transactions on database deadlocks and enforces the READ\_COMMITTED isolation level. Additionally, it includes a sanitizer to bound the cardinality of SQL metrics by collapsing IN-lists and redacting identifiers, and it raises the default HikariCP connection pool size from 10 to 20 to better support concurrent queue polling.
jdbc · high confidence
Memory repository now uses an ephemeral in-memory database for test runs
The memory repository module has been refactored to ensure that flow test runs execute against a temporary, in-memory H2 database rather than any configured persistent database. This is achieved by introducing a \DatasourceProvider\ that configures an H2 instance when the repository or queue type is set to 'memory', and an \EphemeralDatasourceRewriter\ that intercepts and rewrites all datasource configurations to point to this ephemeral URL at startup, clearing any external connection details. This change isolates test data, preventing side effects on production or development databases, and is supported by new test resources and unit tests verifying the rewrite behavior.
repository-memory · high confidence
Migrate JDBC queue implementation to v2
The JDBC queue backend has been replaced with a new v2 implementation that introduces distinct queue types (broadcast, dispatch, keyed dispatch, and VNode dispatch) to better handle different event patterns. This change brings a new subscriber model using explicit polling with offset tracking for broadcast events and routing-key-based dispatching, alongside a dedicated cleaner service to automatically purge old records based on configurable retention periods. Existing queue types are now wired through a new factory, ensuring that execution, flow, scheduler, and worker events are processed using the updated JDBC infrastructure.
queue-jdbc · high confidence
Migrate TriggerEvent queue to new querying API
The scheduler's trigger event handling has been updated to use a new querying API. This change introduces a new \TriggerEventQueue\ interface and its \DefaultTriggerEventQueue\ implementation, which now utilizes a \VNodeDispatchQueueInterface\ to route events based on virtual node IDs. The implementation computes the target virtual node for each event and delivers batches of \TriggerEvent\ objects to consumers, replacing the previous queuing mechanism.
core/src/main/java/io/kestra/core/scheduler/queue · high confidence
Migrate plugin discovery to standard Java ServiceLoader
The plugin processor now generates standard Java ServiceLoader configuration files (in META-INF/services) instead of using a custom mechanism. This change ensures that plugin classes annotated with @Plugin are automatically registered via the standard Java service-provider interface, improving compatibility and maintainability of the plugin discovery process.
processor/src/main/java/io/kestra/core/plugins/processor · high confidence
New Apache HTTP client implementation with logging and metrics
The HTTP client implementation in the core module has been replaced with a new Apache HTTP Client 5-based architecture. This change introduces structured logging for HTTP requests and responses, allowing users to debug network interactions via configurable log levels. It also automatically records operational metrics (request/response counts and byte sizes) into the run context, enabling better observability of HTTP task performance.
core/src/main/java/io/kestra/core/http/client/apache · high confidence
New centralized HTTP client configuration model
The HTTP client configuration has been refactored into a new, centralized model in the \io.kestra.core.http.client.configurations\ package. This introduces a unified \HttpConfiguration\ class that manages timeouts, proxy settings, SSL options, and a new polymorphic authentication system supporting Basic, Bearer, and Digest (RFC 7616) auth types. Users benefit from consistent configuration handling, proper proxy pass-through, and the ability to configure retry policies and allowed response codes directly within this central configuration structure.
core/src/main/java/io/kestra/core/http/client/configurations · high confidence
New dashboard filter model and duration normalization
The dashboard filter system now uses a structured model (AbstractFilter and subclasses like Contains, Regex, Prefix) instead of raw query strings, enabling precise validation and type safety. Duration filters are automatically normalized to the underlying store's unit (milliseconds or seconds) so that ISO-8601 or second-based inputs work correctly across JDBC and ElasticSearch. The Regex filter is validated to prevent catastrophic backtracking, and the Prefix filter now uses a startsWith-based check for namespace prefixes.
core/src/main/java/io/kestra/core/models/dashboards/filters · high confidence
New exception types for clearer error handling
The core exception package now includes several new exception classes to provide more specific error reporting. These include ConflictException and AlreadyExistsException for handling resource conflicts, FlowNotFoundException and TaskNotFoundException for missing resources, ForbiddenException and ResourceAccessDeniedException for access control issues, and InputOutputValidationException for input/output validation errors. Additionally, new exceptions like CyclicGraphException, InvalidQueryFiltersException, and NoMatchingWorkerQueueException have been added to handle specific error scenarios more precisely.
core/src/main/java/io/kestra/core/exceptions · high confidence
New retry strategy models with validation and Failsafe integration
The retry configuration models in \core/src/main/java/io/kestra/core/models/tasks/retrys\ have been replaced with a new structure supporting three distinct strategies: Constant, Exponential, and Random delays. These classes now leverage the \dev.failsafe\ library for policy construction and include strict validation constraints (e.g., positive durations, interval bounds) to prevent invalid configurations. A new \warningOnRetry\ property allows flows to enter a warning state if retry attempts occur, and the \Behavior\ enum introduces options for handling flowable retries differently than standard task retries.
core/src/main/java/io/kestra/core/models/tasks/retrys · high confidence
New validation rules for flows, inputs, dashboards, and triggers
This change introduces a comprehensive set of new constraint validators in the core validation layer to enforce stricter rules at save time. For flows, it prevents duplicate task/trigger/input/output IDs, rejects recursive flow calls, validates that namespaces exist, restricts user-defined system labels, and enforces bracket notation for input/output keys containing dashes. Input validation now forbids specific nested item types (ARRAY, SECRET, MULTISELECT, SELECT) in Array and Multiselect inputs, prevents FORM inputs from having defaults or prefill, and ensures FILE input defaults use only local or namespace file URIs. Dashboard chart validation now checks for required aggregation fields, ensures referenced columns exist, validates duration filters, and restricts the LABELS column to ElasticSearch repositories. Additionally, DAG tasks are validated for cyclic dependencies and missing task IDs, flow triggers require minSatisfied to be set and bounded by dependsOn, and RFC 1123 labels are enforced to a 63-character max.
core/src/main/java/io/kestra/core/validations/validator · high confidence
New worker model records for context, info, and trigger results
This change introduces three new model classes in the worker package to structure internal worker state and communication. WorkerContext now encapsulates worker identity, group, thread count, and a configurable job buffer size. WorkerInfo provides a lazy-loaded supplier for the current worker's unique ID via dependency injection. WorkerTriggerResult replaces previous trigger result structures with a lightweight record containing the trigger ID, type, evaluation result, and dispatch epoch, aligning with the broader refactor to use TriggerEvaluationResult instead of Execution objects.
core/src/main/java/io/kestra/core/worker/models · high confidence
Override retry interceptor to catch all Throwables
A new \OverrideRetryInterceptor\ has been added to the retry module. This interceptor replaces the default retry behavior specifically to ensure that all \Throwable\ types (not just \Exception\) are caught and potentially retried, aligning with the \Retryable\ annotation's configuration for includes/excludes.
core/src/main/java/io/micronaut/retry · high confidence
Pebble expression engine overhaul: new date handling, string comparisons, and resource limits
The Pebble expression engine in the core runner has been significantly refactored to improve reliability, security, and usability. Date handling is now centralized in a new AbstractDate class, supporting a wide range of ISO and SQL formats, explicit time zones, and flexible parsing of existing string formats. String comparison operators (\>, \>=, \<, \<=) now correctly handle string-to-string comparisons. To prevent resource exhaustion, new limits are enforced on output size, indent amounts, and range functions, throwing a RenderLimitExceededException instead of causing heap exhaustion. A new JsonWriter and TypedObjectWriter improve serialization and type-safe concatenation. Additionally, a new PebbleExpressionService exposes all registered filters and functions (with argument defaults and deprecation info) for autocompletion, and a restricted engine mode allows safe display-time expression resolution by masking or blocking unsafe functions like secret() and http().
core/src/main/java/io/kestra/core/runners/pebble · high confidence
Pie charts now default to Donut style
The default visual style for pie charts in dashboards has changed from a standard pie to a donut. This is implemented via the new PieOption class, which sets the PieGraphStyle to DONUT by default, affecting how users see pie-based data visualizations without needing to adjust any settings.
core/src/main/java/io/kestra/plugin/core/dashboard/chart/pies · high confidence
Preview file renderers are now implemented as plugins
File preview rendering in the Kestra UI is now handled by dedicated plugin components (AbstractBase64FileRenderer, ImageFileRenderer, IonFileRenderer, PdfFileRenderer, and TextFileRenderer) rather than built-in controllers. This change ensures that specific file types like Ion, images, PDFs, and text are rendered with their correct formats and types in the UI, resolving issues where binary files were incorrectly displayed as raw text.
core/src/main/java/io/kestra/plugin/core/preview · high confidence
Queue backend externalized into a plugin with case-insensitive type resolution
The queue backend is now implemented as a plugin rather than a core component, selected via the \kestra.queue.type\ configuration property. To ensure compatibility, the type lookup is now case-insensitive (e.g., \postgres\ and \Postgres\ are treated identically), and legacy configuration prefixes are automatically mapped to the new \kestra.queue.\<id\>\ structure with a deprecation warning. This change also introduces a dependency management mechanism (\QueueBackendDependencies\) to guarantee that backend-specific resources (like JDBC datasources) are destroyed after the queues that use them.
core/src/main/java/io/kestra/core/queues/factory · high confidence
Redesigned plugin documentation panel with collapsible sections and property details
The plugin documentation view has been rebuilt to present schema information in a structured, collapsible layout. Users can now view plugin properties, outputs, metrics, and definitions in dedicated sections that can be expanded or collapsed, with URL hash updates to support direct linking. The new PropertyDetail component displays specific validation constraints (such as min/max, patterns, and units) and possible enum values for each property, while the SchemaPropertiesSection adds a filter bar to search through properties and highlights dynamic, beta, and deprecated attributes. Code examples are rendered with syntax highlighting via a shared Shiki highlighter, and the layout supports both a detailed view and a compact mode for the flow editor.
ui/src/components/plugins/schema · high confidence
Refactored flow graph model to support new execution lifecycle branches
The core graph model in the hierarchies package has been refactored to support a more structured representation of flow execution, introducing explicit lifecycle stages. New classes such as GraphClusterFinally, GraphClusterAfterExecution, and GraphClusterRoot define distinct nodes for the finally, after-execution, and root phases of a flow, while the RelationType enum now includes SEQUENTIAL, CHOICE, ERROR, FINALLY, AFTER\_EXECUTION, PARALLEL, and DYNAMIC to describe these relationships. The AbstractGraph base class and its subclasses (GraphTask, GraphTrigger, SubflowGraphTask) have been updated to handle these new branch types and provide a dedicated forExecution() method to sanitize graph data for users with limited permissions, ensuring that sensitive task details are hidden in execution views.
core/src/main/java/io/kestra/core/models/hierarchies · high confidence
Refactored multiple-condition trigger storage and evaluation logic
The multiple-condition trigger mechanism has been refactored to use a new \MultipleConditionStateStore\ interface for managing state, replacing the previous storage approach. This change introduces a \MultipleConditionWindow\ model that tracks time windows, condition results, and execution outputs, enabling features like multi-tenancy and persistent state across evaluations. The \MultipleCondition\ interface now defines evaluation modes (ALL, ANY, AT\_LEAST) and includes logic to determine if a condition is satisfied based on the current window's results, allowing for more flexible and robust trigger conditions.
core/src/main/java/io/kestra/core/models/triggers/multipleflows · high confidence
Refactored secret service with new exception hierarchy and multi-field support
The secret retrieval mechanism has been refactored to introduce a dedicated exception hierarchy (SecretException and SecretNotFoundException) for better error handling, replacing previous implicit failures. The core SecretService now supports a 'full mode' via SecretObject, allowing secret plugins to return additional metadata alongside the secret value, while maintaining backward compatibility for simple string lookups. Additionally, the service now exposes methods to list secrets and retrieve inherited or own-and-inherited secrets, enabling users to discover available secrets and understand their scope within a tenant and namespace.
core/src/main/java/io/kestra/core/secret · high confidence
Refactored service lifecycle and liveness management for improved reliability
The core server module has been refactored to introduce a robust service lifecycle guard that prevents race conditions between asynchronous startup and shutdown, ensuring services are properly torn down without leaving resources orphaned. This change includes a new \AbstractService\ base class with guarded start/stop mechanisms, a redesigned \ServiceLivenessManager\ that coordinates heartbeats and state transitions more reliably, and the introduction of \ServiceLifecycleGuard\ to synchronize concurrent lifecycle events. Additionally, the service state machine has been updated (e.g., renaming EMPTY to INACTIVE) and new interfaces like \ServiceLivenessListener\ and \ServiceLivenessUpdater\ provide hooks for extending liveness behavior, resulting in more stable service registration and termination across the cluster.
core/src/main/java/io/kestra/core/server · high confidence
Refactored task runner architecture with new logging and OTLP support
The task runner subsystem has been restructured to improve reliability and observability. Script execution logs are now consumed via a new \AbstractLogConsumer\ hierarchy (with \DefaultLogConsumer\), enabling structured parsing of output markers and proper handling of debug/info levels. The system now supports capturing and forwarding OpenTelemetry (OTLP) telemetry data from script commands, including logs, metrics, and traces. Additionally, the \TaskRunner\ base class now exposes detailed failure information via \TaskRunnerDetailResult\, allowing users to see underlying runner diagnostics even when a task fails. Remote task runners can now optionally synchronize the working directory back to the local context via the new \syncWorkingDirectory\ property.
core/src/main/java/io/kestra/core/models/tasks/runners · high confidence
Reworked flow model with new concurrency, labels, and input/output structures
The core flow model has been restructured to support new capabilities and stricter validation. Flows now support a \Concurrency\ configuration with a \QUEUE\ behavior and optional \queueLimit\, allowing better control over parallel execution. Labels are now stored as a list of key/value \Label\ objects (supporting both list and map serialization) instead of a simple map. The input system has been significantly expanded with new types (ARRAY, ION, SECRET, EMAIL, FORM, REUSABLE\_INPUTS, etc.), hierarchical input support via \FORM\ grouping, and dependencies between inputs. Flows can now define \Outputs\ to expose data to other flows, and support \finally\ and \afterExecution\ tasks for post-processing. Additionally, flows can be marked as \disabled\ or \draft\, and support \WorkerSelector\ for routing.
core/src/main/java/io/kestra/core/models/flows · high confidence
Script tasks now support execution context files and a new task runner model
Script tasks can now write execution metadata (inputs, outputs, labels, vars, trigger, flow, execution) to a \.kestra-execution-context.json\ file in the working directory via the new \executionContext\ property, allowing scripts to read this data as structured JSON instead of interpolating Pebble expressions into their source. The script plugin also introduces a new \taskRunner\ property to replace the deprecated \runner\ property, with the Docker runner now defaulting to the \IF\_NOT\_PRESENT\ pull policy. Additionally, the \outputFiles\ property is now the recommended way to capture script outputs, deprecating the older \outputDir\ mechanism.
script · high confidence
Standardize plugin discovery and test infrastructure
The processor now registers the PluginProcessor via the standard Java ServiceLoader mechanism (META-INF/services), ensuring consistent plugin detection. Additionally, test execution is configured to output Allure reports to build/allure-results, and a dedicated logback configuration sets test logging to WARN level to reduce noise during unit tests.
processor · high confidence
Suppress specific low-value log messages
The system now filters out four specific log messages to reduce noise: warnings about out-of-order mode schema migration, database version mismatches with the Postgres dialect, unsupported executor binding, and missing cache statistics. This change improves log clarity by hiding these expected or informational messages from the standard output.
core/src/main/java/io/kestra/core/log · high confidence
Task model refactoring and new worker routing capabilities
The core task model has been restructured to introduce new interfaces (ExecutableTask, FlowableTask, RunnableTask, SystemTask) and configuration options. Users can now route tasks to specific workers using tags via the new WorkerSelector (with ALL or ANY matching strategies and configurable fallback behaviors). Additional task-level features include a caching mechanism (Cache), conditional execution (runIf), warning state handling (allowWarning), and the ability to log to files (logToFile). The model also introduces AssetFailureBehavior for asset handling, FileExistComportment for namespace files, and a new TaskResult record for execution metadata.
core/src/main/java/io/kestra/core/models/tasks · high confidence
Trigger evaluations now publish execution commands directly via a dedicated publisher
The scheduler service now uses a new \TriggerExecutionPublisher\ interface and its \DefaultTriggerExecutionPublisher\ implementation to handle trigger evaluations. Instead of creating throwaway executions, the system now converts trigger evaluation results directly into \Create\ commands and emits them to the execution command queue. This change simplifies the trigger execution flow by removing the intermediate execution creation step, relying instead on the command queue to drive execution creation and handling failures by logging errors and emitting failed state commands if the queue is unavailable.
core/src/main/java/io/kestra/core/scheduler/service · high confidence
Trigger model refactoring and new configuration capabilities
The trigger model has been restructured to support new configuration options and a more efficient evaluation process. Triggers now support a \when\ condition to gate execution on dynamic runtime values, \allowConcurrent\ to control parallel runs, and \stopAfter\ to automatically disable triggers based on execution states. The evaluation mechanism has been refactored to use a lightweight \TriggerEvaluationResult\ instead of full Execution objects for internal communication, improving performance. Additionally, the model introduces stateful trigger support via \StatefulTriggerInterface\ and \StatefulTriggerService\ for tracking entity changes, and a new \Backfill\ model to handle historical execution recovery.
core/src/main/java/io/kestra/core/models/triggers · high confidence
Validation errors now use RFC 9457 problem details with precise error locations
The validation subsystem has been refactored to report constraint violations using the RFC 9457 problem details format. This change introduces a new \ValidationError\ record that includes both a machine-readable RFC 6901 JSON Pointer and a human-friendly path (e.g., \tasks\[my-task\].message\ instead of \tasks\[0\].message\) for every error. To support this, new helper classes (\ManualConstraintViolation\, \ManualPath\, \ManualPropertyNode\, \ViolationPaths\) were added to correctly map validation paths to document locations, and \KestraConstraintViolationException\ now aggregates these violations. Users will see more structured, standardized error responses that make it easier to programmatically identify and fix validation issues in flows and templates.
core/src/main/java/io/kestra/core/models/validations · high confidence
Fixes
Fix CLI no-args help display via EnvironmentProvider registration
The CLI now correctly displays help when invoked with no arguments. This is achieved by adding a service provider configuration file for io.kestra.cli.services.EnvironmentProvider that registers io.kestra.cli.services.DefaultEnvironmentProvider, ensuring the default environment configuration is properly loaded during startup.
cli/src/main/resources/META-INF · high confidence
Fix Docker build failure when plugins directory is missing
The Docker build process now handles the absence of the plugins directory gracefully. A .gitkeep file has been added to the plugins directory to ensure it is tracked by version control, preventing build errors that occurred when the directory was not present during the build context mounting.
plugins · high confidence
Fix Hibernate Validator bean instantiation crashes due to parameter name mismatches
A new OverrideParameterNameProvider replaces Micronaut's default parameter name provider to prevent crashes when Hibernate Validator attempts to instantiate beans. The provider normalizes parameter name lists by trimming extra internal parameters and padding missing names with placeholders, ensuring that the number of names matches the actual constructor or method parameter count.
core/src/main/java/io/micronaut/configuration · high confidence
Local storage implementation with security and cross-platform fixes
The local storage backend now enforces strict path traversal guards that reject Windows-style backslash attacks ([GHSA redacted]) and limits object names to 255 characters. It also ensures reliable cross-platform operation by normalizing Windows backslashes to forward slashes and automatically creates parent directories during moves and deletes, while properly cleaning up companion metadata files to prevent orphans.
storage-local · high confidence
Test coverage
Added CLI integration tests for Kestra command-line behavior; Added CLI plugin command tests; Added JSON validation test for Pebble templates; Added Mockito inline mock maker configuration for tests; Added contract tests for MultipleConditionStateStore implementations; Added core model classes for Test Suite functionality; Added repository test suites for concurrency limits, execution outputs, statistics, flows, topology, KV metadata, and locks; Added repository tests for MCP server and session persistence; Added test coverage for CLI config commands and no-repo scenarios; Added test coverage for Kestra core storage components; Added test coverage for core flow execution behaviors; Added test coverage for core storage plugin tasks; Added test coverage for execution control and variable management tasks; Added test coverage for runner concurrency, retry, and execution lifecycle; Added test fixtures for deprecated task classes; Added test for KVEntry JSON serialization using 'revision' key; Added test for MarkdownSource JSON serialization; Added test for Process task runner; Added test for namespace command help output; Added test for retry interceptor override behavior; Added test resources for namespace file ignore patterns; Added test resources for sequential task execution and OTLP telemetry parsing; Added test to verify Prometheus and Metrics endpoints are not sensitive; Added test utilities and sanity checks for core task behaviors; Added test utilities for plugin aliases, asset emission, and error handling; Added test utilities for scheduler event queues and vNode assignment; Added tests for AI agent models and repository abstractions; Added tests for AsyncEventStreamingService event dispatching; Added tests for Basic Auth endpoint filter behavior; Added tests for CLI migration commands and context; Added tests for CLI server commands and context isolation; Added tests for Check behavior resolution logic; Added tests for CrudEvent and EventId serialization; Added tests for ExecutionService notification logic; Added tests for HTTP client security and functionality; Added tests for JUnit extension shutdown guards and directory flow loading; Added tests for KV store CLI commands; Added tests for Log and PurgeLogs tasks; Added tests for LogRecordMapper; Added tests for NoopCache behavior; Added tests for OutputValues task and PluginUtilsService; Added tests for Pebble functions; Added tests for Pebble template rendering, output limits, and documentation drift; Added tests for Property value extraction and validation; Added tests for Publish and PurgeMetrics tasks; Added tests for ServicesFiles utility; Added tests for TriggerState dispatch epoch behavior; Added tests for asset failure behavior and worker selector validation; Added tests for asset model updates and validation rules; Added tests for configuration file deletion on startup; Added tests for core file preview renderers; Added tests for dashboard global filter handling in data sources; Added tests for dashboard query timeout configuration; Added tests for dashboard query timeout validation and duration filter normalization; Added tests for dynamic property rendering and URI fetching; Added tests for flow CLI commands; Added tests for flow graph generation and execution visualization; Added tests for flow input type census and service usage statistics; Added tests for flow input validation and rendering; Added tests for flow model validation and state behavior; Added tests for flow topology and dependency resolution; Added tests for internal call context and ZIP bomb protection; Added tests for label-based metric tagging; Added tests for legacy queue configuration mapping and case-insensitive queue type resolution; Added tests for namespace file management tasks; Added tests for namespace file metadata state store; Added tests for namespace prefix matching and hierarchy expansion; Added tests for no-database command context isolation; Added tests for plugin serialization and deserialization; Added tests for plugin subsystems; Added tests for scheduler trigger event serialization and deserialization; Added tests for task runner log consumption and script service validation; Added tests for test suite assertion logic and run result states; Added tests for the CLI reindex command; Added tests for the LockService; Added tests for the configuration schema generator; Added tests for the memory runner repository; Added tests for the notification system's repository, service, and streaming components; Added tests for trigger state persistence and timezone-aware time windows; Added tests for usage reporting and scheduling logic; Added tests for validation error serialization and path handling; Added tests for worker queue routing, metadata caching, and broadcast events; Added unit tests for CLI services; Added unit tests for EncryptionService null and empty handling; Added unit tests for Execution Assertion and Max Duration SLA types; Added unit tests for HTTP plugin tasks; Added unit tests for KV Store plugin tasks; Added unit tests for Pebble expression evaluation; Added unit tests for Pebble template filters; Added unit tests for StackdriverJsonLayout; Added unit tests for TemplatedTask validation and execution; Added unit tests for TenantService; Added unit tests for constant, exponential, and random retry strategies; Added unit tests for core context configurations and API client behavior; Added unit tests for core model validation and query filter logic; Added unit tests for core trigger plugins; Added unit tests for core utility classes; Added unit tests for execution models and metrics serialization; Added unit tests for queue lag behavior and QueueService key resolution; Added unit tests for serialization and file I/O components; Added unit tests for server-side service lifecycle and liveness components; Added unit tests for the MigrationRunner component; Added unit tests for vnodes scheduler components; Added validation tests for core configuration and model constraints; E2E test suite is now a standalone npm package; New JUnit 5 test fixtures and annotations for flow execution and trigger evaluation; New unit test model and assertion framework; Removed Bash task test; Removed StandAloneRunnerTest; Removed YamlFlowParserTest; Removed test utility class Utils; Tests for secret function arguments and masking behavior.
Dependencies
2014 commits updating dependencies (36 manifests)
A dependency / build maintenance change in (dependencies) — 2014 commits (223 fixs), 36 files.
(dependencies) · high confidence · unverified
Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 50 → 46 (-3.8)
Lenses
- Code Health 70 → 70 (+0.2)
- Architecture 63 → 62 (-0.8)
- Maturity 74 → 74 (-0.1)
- Readiness 41 → 32 (-8.6)
- Security 53 → 64 (+11.1)
- Domain Modelling 100 → 80 (-19.3)
- Accessibility 54 → 49 (-5.1)
- Performance 73 → 77 (+4.1)
Resolved (149)
- Banned license: com.mysql:mysql-connector-j
- Change coupling: ExecutionController.java ↔ LogController.java (webserver/src/main/java/io/kestra/webserver/controllers/api/ExecutionController.java)
- Change coupling: Executor.java ↔ ExecutorService.java (core/src/main/java/io/kestra/core/runners/Executor.java)
- Change-coupling hub: InputsForm.vue → Input.java, Type.java, MultiselectInput.java (ui/src/components/inputs/InputsForm.vue)
- Duplicated block (10 lines × 2) (jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcFlowRepository.java)
- Duplicated block (11 lines × 2) (scheduler/src/main/java/io/kestra/scheduler/TriggerEventHandler.java)
- Duplicated block (11–13 lines × 2) (executor/src/main/java/io/kestra/executor/handler/ExecutionCommandMessageHandler.java)
- Duplicated block (11–13 lines × 2) (jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcLogDataStore.java)
- Duplicated block (12 lines × 2) (core/src/main/java/io/kestra/core/executor/command/Restart.java)
- Duplicated block (13 lines × 3) (core/src/main/java/io/kestra/core/services/ExecutionStreamingService.java)
- Duplicated block (18 lines × 2) (core/src/main/java/io/kestra/core/validations/validator/ArrayInputValidator.java)
- Duplicated block (6 lines × 2) (core/src/main/java/io/kestra/core/runners/RunVariables.java)
- Edited copy of a member (18 corresponding lines) (jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcLogDataStore.java)
- Execution.guessFinalState (cognitive 17) (core/src/main/java/io/kestra/core/models/executions/Execution.java)
- Execution.guessFinalState (cyclomatic 16) (core/src/main/java/io/kestra/core/models/executions/Execution.java)
- FixmeComment (cli/src/main/java/io/kestra/cli/services/FileChangedEventListener.java)
- High CVE: [GHSA redacted] (ui/package-lock.json)
- High CVE: [GHSA redacted] (ui/package-lock.json)
- High CVE: [GHSA redacted] (ui/package-lock.json)
- High CVE: [GHSA redacted] (ui/package-lock.json)
- …and 129 more
New (192)
- Change-coupling hub: InputsForm.vue → Input.java, Type.java, MultiselectInput.java, SelectInput.java (ui/src/components/inputs/InputsForm.vue)
- ClassTooLong: useDependencies (ui/src/components/dependencies/composables/useDependencies.ts)
- Duplicated block (10 lines × 2) (core/src/main/java/io/kestra/core/runners/RunVariables.java)
- Duplicated block (13 lines × 2) (core/src/main/java/io/kestra/core/executor/command/Restart.java)
- Duplicated block (13 lines × 4) (core/src/main/java/io/kestra/core/notification/NotificationStreamingService.java)
- Duplicated block (15 lines × 2) (jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcCheckpointRepository.java)
- Duplicated block (16–17 lines × 2) (jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcLogDataStore.java)
- Duplicated block (19 lines × 2) (core/src/main/java/io/kestra/core/validations/validator/ArrayInputValidator.java)
- Duplicated block (5 lines × 2) (jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcExecutionRepository.java)
- Duplicated block (7 lines × 2) (core/src/main/java/io/kestra/core/queues/factory/QueueConfig.java)
- Duplicated block (9 lines × 3) (queue/src/main/java/io/kestra/queue/AbstractBroadcastQueue.java)
- Edited copy of a member (19 corresponding lines) (jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcLogDataStore.java)
- Execution.computeFinalState (cognitive 20) (core/src/main/java/io/kestra/core/models/executions/Execution.java)
- Execution.computeFinalState (cyclomatic 19) (core/src/main/java/io/kestra/core/models/executions/Execution.java)
- ExecutionDelayProcessor.process (cyclomatic 17) (executor/src/main/java/io/kestra/executor/ExecutionDelayProcessor.java)
- FileTooLong: runners/FlowInputOutput.java (core/src/main/java/io/kestra/core/runners/FlowInputOutput.java)
- Flaky test: ui/packages/topology/src/Topology.test.ts::Topology view refit should fit the view once on the initial render
- Flaky test: ui/packages/topology/src/Topology.test.ts::Topology view refit should not recentre the view when live task progress bumps taskDetailsVersion
- Flaky test: ui/packages/topology/src/Topology.test.ts::Topology view refit should not recentre the view when the graph data is refreshed
- Flaky test: ui/packages/topology/src/Topology.test.ts::Topology view refit should refit when a subflow expansion reloads the graph
- …and 172 more
Changes since last survey
- 300 commits — 177 feature/other, 123 fixes
By area
- ui/src — 155 commits
- ui/packages — 65 commits
- core/src — 34 commits
- platform/build.gradle — 9 commits
- executor/src — 7 commits
- jdbc/src — 6 commits
- .github/workflows — 5 commits
- (root) — 4 commits
- webserver/src — 3 commits
- script/src — 2 commits
- ui/scripts — 2 commits
- cli/src — 1 commit
- e2e/namespace-files — 1 commit
- jdbc-h2/src — 1 commit
- jdbc-mysql/src — 1 commit
- queue-jdbc/src — 1 commit
- ui/package.json — 1 commit
- ui/tests — 1 commit
- worker-controller/build.gradle — 1 commit
Notable commits
- fix: fix(blueprints): guard getBlueprint against superseded blueprint load responses (#21072)
- fix: fix(compose): raise Postgres healthcheck interval to 10s
- fix: fix(compose): wait for healthy Postgres before starting Kestra
- fix: fix(core): add missing locked features to OSS menus (#21666)
- fix: fix(core): apply the safe regex check to input validators
- fix: fix(core): drain queued executions once their concurrency limit is removed
- fix: fix(core): handle expired keys in kv.Get (#21532)
- fix: fix(core): keep identifiers case-sensitive on mysql
- fix: fix(core): log the class of an exception cause that has no message (#21658)
- fix: fix(core): never let the plugin auto-install migration stop the server
- fix: fix(core): preserve the context path in frontend api requests (#21155)
- fix: fix(core): render the kv.Put value only once (#21698)
- fix: fix(core): replace bootstrap utility classes in Interrupt.vue with design system tokens (#21235)
- fix: fix(core): resolve the queue type ignoring case
- fix: fix(core): translate the Workspace and Resources sidebar headers (#20942)
- fix: fix(core): unit test teardown errors and <i18n-t> scope warnings (#21677)
- fix: fix(dashboards): add missing colon after data in Executions example (#21543)
- fix: fix(dashboards): follow the app locale in the dashboard pie total (#21198)
- fix: fix(dashboards): keep each dashboard's saved filters to itself (#21756)
- fix: fix(dashboards): label weekly buckets with the ISO week-year so they stay in time order (#21360)
- …and 280 more
Architecture
- Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 3 added · 2 removed
Added bounded contexts (1)
- jmh-benchmarks
Added dependency edges (3)
- jmh-benchmarks → core
- queue → core
- queue-jdbc → core
Removed dependency edges (was a dependency, now gone) (2)
- queue → core (coupling)
- queue-jdbc → core (coupling)
Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
kestra-io/kestra 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.
About this page
- The score is its most recent published measurement, taken on 24 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit bad4d5b551cd14242564ddac5db9791553871c41 — the exact code this score is about.
- Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
- Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.6+preprod-d36780c2d857.