apache/airflow
47.7
Weak · 14 November 2026
853.1k
lines of production code
Python
with TypeScript
6
measurements over time
What this system is
Features
Add Configs page to display Airflow configuration options
A new Configs page has been added to the Airflow UI, allowing users to view system configuration settings. The page fetches configuration data via the API and displays it in a table with columns for section, key, and value. It integrates with the existing DataTable component for rendering and uses i18n for localized headers.
airflow-core/src/airflow/ui/src/pages/Configs · high confidence
Add Deadlines page to the Browse section
A new Deadlines page has been added under the Browse section, allowing users to view a table of deadline events for DAG runs. The page displays key details such as the DAG ID, DAG run ID, deadline time, alert name, and creation time. It includes a status indicator (missed or pending) and, in multi-team deployments, a team column. Users can filter the list by DAG ID, deadline time range, missed status, and team, with table state (sorting, pagination, filters) persisted in the URL.
airflow-core/src/airflow/ui/src/pages/Deadlines · high confidence
Add Java SDK example project with annotation, interface, and native DAG demonstrations
The java-sdk/example directory now contains a complete example project that demonstrates how to build and run Airflow workflows using the Java SDK. It includes stub-based tasks (AnnotationExample, InterfaceExample, XComCastingExample) that integrate with Python-defined DAGs, showcasing features like XCom casting, keyword argument binding, and concurrent client calls. Additionally, it provides pure-Java native DAGs (nativedag.AnnotationExample, nativedag.InterfaceExample, nativedag.TargetExample) that define their own graph structure using annotations or the interface API, including conditional branching, switching, task grouping, and triggering downstream DAGs.
java-sdk/example · high confidence
Add PoolSummary widget to the Dashboard
A new PoolSummary component has been added to the Dashboard, providing a consolidated view of pool slot usage across all pools. It aggregates running, queued, scheduled, and open slots into a single visual bar, while separately displaying deferred slots that do not count against pool limits (based on the include\_deferred setting) via a tooltip. The widget respects user permissions, hiding the 'Manage Pools' link if access is denied, and handles unlimited pools correctly.
airflow-core/src/airflow/ui/src/pages/Dashboard/PoolSummary · high confidence
Add Scala Spark ETL example to Java SDK
This change introduces a new Scala-based Apache Spark ETL example within the Java SDK. It includes a DAG definition (\scala\_spark\_examples.py\) that orchestrates three tasks—extract, transform, and load—along with the corresponding Scala implementation (\ScalaSparkExample.scala\) that uses the Java SDK's \Task\ and \DagDef\ APIs to run Spark sessions and pass data via XComs. A \log4j2.xml\ configuration is also added to route Spark and task logs into Airflow's logging system, ensuring Spark output remains readable by pinning Spark loggers to WARN level.
_java-sdk/scala\_spark\example · high confidence
Add Task State Store management UI for mapped tasks
The UI now includes a dedicated Task State Store page and associated components (Add, Edit, Delete, and Clear All buttons, plus a modal) that allow users to manage key-value state for specific task instances. This implementation specifically supports mapped tasks by correctly passing and using regional coordinates (regionId and regionIndex) to ensure state operations target the exact loop iteration, and it handles expiration settings including custom datetimes with proper timezone conversion.
airflow-core/src/airflow/ui/src/pages/TaskStateStore · high confidence
Add favorite DAGs section to the dashboard
The dashboard now includes a new 'Favorite DAGs' section that displays up to 10 user-pinned DAGs. This feature introduces a new UI component that fetches favorite DAGs via the API and renders them as cards showing the latest run status and a link to the DAG details. If no favorites are selected, a placeholder message is shown.
airflow-core/src/airflow/ui/src/pages/Dashboard/FavoriteDags · high confidence
Add shared template value truncation logic
A new shared module for template rendering has been introduced, providing a \truncate\_rendered\_value\ function and associated configuration constants (\TRUNCATE\_PREFIX\, \TRUNCATE\_SUFFIX\, \TRUNCATE\_MIN\_CONTENT\_LENGTH\). This function allows rendered template values to be truncated to a specified maximum length, ensuring that output fields do not exceed configured size limits while preserving a clear indication that truncation occurred.
_shared/template\rendering · high confidence
Add task-level filtering to the DAG Tasks view
Users can now filter the list of tasks within the DAG view by operator, trigger rule, retry count, and mapped status, as well as search by task name. This new TaskFilters component integrates with URL search parameters to maintain filter state across navigation and includes a reset button to clear all active filters.
airflow-core/src/airflow/ui/src/pages/Dag/Tasks/TaskFilters · high confidence
Added core HTTP client utilities for the Airflow UI
The Airflow UI now includes a new set of TypeScript files in the \openapi-gen/requests/core\ directory to handle API communication. These files introduce a \CancelablePromise\ class for managing cancellable HTTP requests, an \ApiError\ class for structured error handling, and configuration types (\OpenAPI\, \ApiRequestOptions\, \ApiResult\) that define how requests are constructed and processed. This infrastructure supports the underlying API client generation used by the frontend.
airflow-core/src/airflow/ui/openapi-gen/requests/core · high confidence
Apache HDFS provider restructured for Airflow 2.11+ with new asset and logging capabilities
The Apache HDFS provider has been moved to a new package structure and now requires Apache Airflow 2.11.0 or later. This update introduces support for HDFS URIs as Airflow Assets, enabling automatic asset creation and OpenLineage conversion for 'hdfs://' schemes. Additionally, the provider now supports HDFS as a remote logging scheme via HdfsRemoteLogIO, and the WebHDFSHook has been enhanced to accept custom headers and cookies through connection extra parameters.
providers/apache/hdfs · high confidence
Apache Spark provider version 6.3.3 with Airflow 2.11+ requirement and new PySpark task decorator
The Apache Spark provider has been updated to version 6.3.3, which now requires Apache Airflow 2.11.0 or later. This release introduces a new \@task.pyspark\ decorator, allowing users to define PySpark tasks directly as Python functions, and adds support for Spark Connect connections via a new \SparkConnectHook\. The provider also includes a new \SparkPipelinesHook\ for interacting with Spark Declarative Pipelines and migrates connection UI metadata to YAML for better maintainability.
providers/apache/spark · high confidence
Asset State Store management UI
The Asset detail page now includes a dedicated state store view where users can manage key-value pairs associated with an asset. This new section provides a table listing all stored entries, showing the key, value, last updated timestamp, and the task that last modified the entry (with a clickable link to that task instance). Users can add new state entries, edit existing ones, delete individual entries, or clear the entire store for the asset.
airflow-core/src/airflow/ui/src/pages/Asset/AssetStateStore · high confidence
Assets list page now shows dependencies and supports advanced filtering
The Assets list page now displays consuming tasks, aliases, and watchers for each asset via interactive popovers, and includes a new 'Dag ID' filter for exact-match filtering alongside the existing 'Has Events' filter. The list also shows the last asset event timestamp and supports multi-sorting, with search parameters persisted in the URL for better navigation and state preservation across page loads.
airflow-core/src/airflow/ui/src/pages/AssetsList · high confidence
Backfills UI now supports filtering and detailed run inspection
The Backfills tab in the DAG details page now includes a filter bar that lets you narrow backfills by date ranges (from/to, created, completed), duration, max active runs, and reprocess behavior. Clicking a backfill opens a modal that lists its individual DAG runs, showing logical date or partition key, run state, exception reason, and a link to the run details, with automatic polling while the backfill is still running.
airflow-core/src/airflow/ui/src/pages/Dag/Backfills · high confidence
Bulk actions and enhanced filtering for Dag Runs
The Dag Runs list page now supports bulk operations, allowing users to select multiple runs and clear, delete, or mark them as success/failed in a single action via new BulkClearDagRunsButton, BulkDeleteDagRunsButton, and BulkMarkDagRunsAsButton components. The list view has been expanded with additional columns including logical date, run type, and team name (when multi-team is enabled), and the configuration column now features expand/collapse controls for JSON content. Filtering capabilities have also been improved with the addition of tag-based filtering (supporting both any/all match modes) and a dedicated logical date range filter, alongside existing filters for state, run type, and duration.
airflow-core/src/airflow/ui/src/pages/DagRuns · high confidence
Bulk actions and enhanced navigation for Task Instances
The Task Instances page now supports bulk operations, allowing users to select multiple task instances to clear, delete, or mark as a specific state (success/fail) in a single action. The interface includes dedicated buttons for these bulk operations, with confirmation modals that group task instances by DAG run for clarity. Additionally, the map index column now provides clickable links to individual mapped task instances, and the Dag Run ID column links directly to the corresponding DAG run, improving navigation and workflow efficiency.
airflow-core/src/airflow/ui/src/pages/TaskInstances · high confidence
Centralized keyboard shortcut registry and help dialog
The UI now includes a centralized registry for keyboard shortcuts, allowing users to discover available key bindings via a help dialog (triggered by pressing ? or shift+/). This change introduces a new context and provider system that dynamically tracks active shortcuts across the application, ensuring the help modal always reflects the shortcuts available on the current page. It also defines specific shortcuts for various contexts, including logs (e.g., toggle log level with 'l', toggle wrap with 'w'), DAG view, navigation, and run actions, providing a consistent and discoverable way to interact with the interface.
airflow-core/src/airflow/ui/src/context/keyboardShortcuts · high confidence
Cohere provider updated to require Airflow 2.11+ and adds Rerank operator
The Cohere provider now enforces a minimum Apache Airflow version of 2.11.0, ensuring compatibility with the latest platform features. This update introduces a new \CohereRerankOperator\ that allows users to rerank documents by relevance using Cohere's Rerank API, complementing the existing embedding capabilities. The provider also migrates to the Airflow 3.0 compatibility layer, updating the \CohereHook\ to inherit from the SDK's \BaseHook\ and standardizing connection UI behavior.
providers/cohere · high confidence
Connections page UI is rebuilt with new form, actions, and testing capabilities
The Connections page UI has been completely rewritten to provide a more robust and feature-rich experience. The new implementation includes a dedicated ConnectionForm component that supports both adding and editing connections, with improved handling of provider-specific fields and JSON validation. A new TestConnectionButton allows users to verify connection connectivity directly from the list view, with results displayed via status icons. The page now supports bulk deletion of connections through a new DeleteConnectionsButton component, alongside the existing single-connection deletion. The form includes a TeamSelector for multi-team environments and uses a lazy-mounted modal for better performance. The list view features improved search functionality with advanced search options and URL state persistence for pagination and sorting.
airflow-core/src/airflow/ui/src/pages/Connections · high confidence
Dag Overview now displays deadline alerts and collapsible failed task logs
The Dag Overview page now includes a new 'Deadlines' section that lists upcoming and missed deadlines for the selected DAG, with a 'Show all' button that opens a paginated modal for full details. Additionally, a 'Failed Logs' section has been added to the overview, displaying the last five failed task instances with a collapsible preview of their error logs, a toggle to wrap text, and a keyboard shortcut (W) to toggle wrapping.
airflow-core/src/airflow/ui/src/pages/Dag/Overview · high confidence
Dashboard now displays DAG and plugin import errors with reparse capability
The Dashboard Stats section now includes dedicated cards for DAG and plugin import errors. Clicking these cards opens a modal listing the errors, where users can search by filename or source, copy error details, and trigger a reparse for DAG files to attempt recovery. The dashboard also features auto-refresh logic that continues polling after a reparse is issued, ensuring the error count updates as the DAG processor handles the request.
airflow-core/src/airflow/ui/src/pages/Dashboard/Stats · high confidence
Dashboard now displays deadline tracking and configurable alert management
The Dashboard page now includes a new Deadlines section that lists pending and recently missed deadlines for DAGs, allowing users to quickly identify scheduling issues. Additionally, the dashboard now supports displaying system alerts configured via the API; these alerts are clamped to a maximum height with a 'See more' toggle for long text, and users can collapse the alert list, with the state persisted in local storage.
airflow-core/src/airflow/ui/src/pages/Dashboard · high confidence
Discord provider restructured with async support and embeds
The Discord provider has been reorganized into a new package structure (version 3.12.4) and now requires Apache Airflow 2.11.0 or later. This update introduces an asynchronous notifier (\DiscordNotifier\) and an async hook (\DiscordWebhookAsyncHook\), enabling non-blocking message delivery. It also adds support for Discord embeds, allowing users to send rich, structured messages with titles, descriptions, and fields via the new \embed\ parameter in operators and notifications.
providers/discord · high confidence
Docker provider restructured for Airflow 3.0 with new task decorator
The Docker provider has been migrated to the new provider structure and updated to require Apache Airflow 2.11.0 or later, enforcing this minimum version at import time. This change introduces a new \@task.docker\ decorator that allows wrapping Python callables to run inside Docker containers, supporting configurable serialization (pickle, cloudpickle, dill). The provider's internal components, including the \DockerHook\, \DockerOperator\, and \DockerSwarmOperator\, have been refactored to use version-compatible imports from the Airflow SDK for Airflow 3.0+ while maintaining back-compatibility for earlier versions. Exception classes have also been moved to align with the new TaskSDK structure.
providers/docker · high confidence
Documentation build tooling and styling updates
The documentation build system now includes custom CSS for the sphinx-design extension and Swagger UI, improving tab styling, warning admonitions, and dark-mode readability for API references. A new Sphinx extension resolves cross-references for symbols re-exported via \airflow.providers.common.compat.sdk\, ensuring these links render correctly in generated documentation. Additionally, the 'Suggest a change' button is now suppressed on autoapi-generated reference pages to prevent broken edit links, and a README provides updated guidance for building and editing Airflow documentation locally.
devel-common · high confidence
Edge UI plugin generated from OpenAPI spec
The Edge UI plugin now includes a generated TypeScript client and React Query hooks (via @hey-api/openapi-ts and @7nohe/openapi-react-query-codegen) that provide type-safe access to the Edge worker REST API. This enables the UI to fetch jobs, manage worker states, handle maintenance and shutdown requests, and update concurrency limits with full type safety and caching.
providers/edge3/src/airflow/providers/edge3/plugins/www · high confidence
Enhanced DAG Code tab with version diffing and file location display
The DAG Code tab now supports comparing two stored DAG versions side-by-side using a new diff viewer, allowing users to see changes between versions. Additionally, the tab displays the source file name (with a tooltip for the full path and a copy button) to help identify which file is being viewed, and handles cases where the DAG source file is missing by showing an appropriate empty state instead of an error.
airflow-core/src/airflow/ui/src/pages/Dag/Code · high confidence
Execution API routes reorganized and expanded with new endpoints
The Execution API route structure has been reorganized into a modular layout under \airflow/api\_fastapi/execution\api/routes\, with a central \\\init\\_.py\ registering all sub-routers under a single authenticated \VersionedAPIRouter\. This change introduces several new endpoints: a Human-in-the-Loop (HITL) interface at \/hitlDetails\ for managing task approval workflows, a dedicated \/store/ti\ and \/store/asset\ for task and asset state storage, and new asset event querying capabilities at \/asset-events/by-asset\ and \/asset-events/by-asset-alias\ that support filtering by partition keys, time ranges, and extra metadata. Additional updates include a \/callbacks\ endpoint for exchanging single-use callback tokens, a \/connection-tests\ interface for managing connection validation states, and a \/task-reschedules\ endpoint to retrieve the first reschedule start date for a task instance.
_airflow-core/src/airflow/api\_fastapi/execution\api/routes · high confidence
FAB auth manager API endpoints migrate to FastAPI
The FAB provider now exposes its authentication, user, and role management endpoints via a new FastAPI-based API (under /fab/v1) instead of the previous Flask/Connexion implementation. This change introduces dedicated route modules for login, roles, and users, along with corresponding Pydantic data models and an OpenAPI specification, providing a modern, standardized REST interface for managing FAB auth resources.
providers/fab · high confidence
FlexibleForm now supports a comprehensive set of parameter types
The FlexibleForm component has been significantly expanded to support a wide variety of parameter types, ensuring that users can correctly input and edit complex data in connection and trigger forms. New dedicated field components have been added to handle specific data formats: \FieldAdvancedArray\ and \FieldObject\ provide JSON editors for arrays and objects; \FieldDateTime\ handles date, time, and datetime inputs with proper validation; \FieldDuration\ parses and validates ISO 8601 duration strings; \FieldDropdown\ and \FieldMultiSelect\ manage single and multiple enum selections, including support for null values; \FieldMultiType\ allows flexible input for parameters that can be strings, numbers, booleans, or objects; and \FieldPassword\ provides masked input for sensitive credentials. These changes ensure that the UI correctly reflects the schema of the parameters, preventing validation errors and improving the user experience when configuring Airflow connections and triggers.
airflow-core/src/airflow/ui/src/components/FlexibleForm · high confidence
Grid view restructured with virtualization and version indicators
The Grid view layout has been rebuilt to support virtualization for improved performance with large datasets, and now includes visual indicators for DAG and bundle version changes. Users will see version change markers on run bars and task cells, and the view now supports pagination with buttons to navigate between older and newer runs. The grid also features a run type legend and improved tooltip behavior that respects timezone settings.
airflow-core/src/airflow/ui/src/layouts/Details/Grid · high confidence
Human-in-the-loop task instances page and response form
The Human-in-the-loop (HITL) Task Instances listing page now provides a dedicated UI for managing required actions. Users can filter task instances by response status, responder, mapped index, subject/body content, date range, and (when multi-team is enabled) by team. The HITL response form correctly handles pending states for both legacy 'deferred' and new 'awaiting\_input' tasks, and fixes a bug where exactly four options failed to render per-option buttons. The listing also correctly passes the map\_index URL parameter to the API, ensuring mapped task instances are visible when explicitly requested.
airflow-core/src/airflow/ui/src/pages/HITLTaskInstances · high confidence
InfluxDB provider adds InfluxDB 3 support and deferrable execution
The InfluxDB provider now includes dedicated hooks, operators, sensors, and triggers for InfluxDB 3.x, enabling SQL-based interactions with the new API alongside the existing InfluxDB 2.x support. The new InfluxDB 3 operator and sensor support deferrable mode, allowing long-running queries and polling to run in the triggerer rather than occupying a worker slot. Additionally, the provider has been updated to require Apache Airflow 2.11.0 or later and migrated its base classes to the common.compat SDK for compatibility.
providers/influxdb · high confidence
Initial release of Docker Stack documentation
This change introduces the complete documentation set for the Apache Airflow Docker images, including the README, build argument reference, build instructions, and changelog. It provides users with detailed guidance on extending and customizing the production images, lists the default extras and providers included in the reference images, and documents the transition to Python 3.13 support and the removal of Python 3.10. The documentation also clarifies the new build process using Debian Bookworm as the base and compiling Python from source, along with examples for adding custom dependencies and configuring build arguments.
docker-stack-docs · high confidence
Initial release of airflowctl CLI documentation and configuration
This change introduces the foundational documentation, configuration, and metadata files for the airflowctl command-line tool. It adds a README with usage instructions, a RELEASE\_NOTES file covering versions 0.1.1 through 0.1.5, and a Sphinx documentation configuration (conf.py) to generate API references. Additionally, it includes a pre-commit configuration to enforce static checks and help-text generation, a .gitignore for the distribution, and various documentation assets such as CLI command reference pages, how-to guides, and SVG diagrams illustrating the tool's architecture and command structures.
airflow-ctl · high confidence
Initial release of the Apache Airflow Python client package
The \clients\ directory now includes the source structure for the official Apache Airflow Python client (version 3.3.2). This package provides a generated SDK for interacting with the Airflow REST API, including installation instructions, a changelog detailing API improvements and bug fixes, and a test script demonstrating usage with Bearer token authentication.
clients · high confidence
Initial release of the Apache Airflow TypeScript SDK (0.1.0-beta1)
The Apache Airflow TypeScript SDK is now available as a beta package, enabling users to author native DAGs and implement Python DAG stub tasks using TypeScript. The SDK provides a \Dag\ class for defining DAG structure, schedules, and tasks entirely in TypeScript, alongside a \TaskHandler\ class for implementing stub tasks in Python DAGs. It supports mixed-language workflows, human-in-the-loop tasks via \approval\ and \hitl\, conditional branching (\dag.if\), multi-way branching (\dag.switch\), and order-only edges (\before\/\after\). The package includes a bundler (\airflow-ts-pack\) to create deployable bundles, a Node.js coordinator for task execution, and comprehensive documentation and API references.
ts-sdk · high confidence
Initial release of the YDB provider for Apache Airflow
This change introduces the new \apache-airflow-providers-ydb\ package, enabling users to interact with YDB databases within Airflow workflows. The provider includes a \YDBHook\ for database connectivity, a \YDBExecuteQueryOperator\ for running SQL queries, and support for multiple authentication methods including login, IAM tokens, service account JSON, and VM metadata. It requires Apache Airflow 2.11.0 or later.
providers/ydb · high confidence
Introduce @task.sql and @task.analytics decorators and DataFusion engine
The common SQL provider now includes TaskFlow-style decorators (@task.sql and @task.analytics) that allow users to define SQL queries dynamically via Python callables, as well as a new DataFusion engine that enables querying object storage (S3, GCS, Azure, local) and Iceberg tables directly. This change also adds configuration support for data sources and format handlers for Parquet, CSV, Avro, and Iceberg.
providers/common/sql · high confidence
Introduce Apache TinkerPop provider with Gremlin integration
The new Apache TinkerPop provider adds support for graph databases via the Gremlin traversal language. It includes a \GremlinHook\ for establishing connections and executing Gremlin queries, and a \GremlinOperator\ that allows users to run Gremlin queries directly within Airflow DAGs. The provider requires Apache Airflow 2.11.0 or later and registers a dedicated 'Gremlin' connection type to manage connection credentials.
providers/apache/tinkerpop · high confidence
Introduce Calendar view for DAGs with granular run tracking
Users can now view DAG run history in a Calendar tab, offering both hourly and daily granularity. The view supports a 'failed' filter to isolate failures, displays backfill indicators, and highlights upcoming or missed deadlines. It respects the user's selected timezone for date calculations and persists view preferences (granularity, mode, date) in the URL for easy sharing and navigation.
airflow-core/src/airflow/ui/src/pages/Dag/Calendar · high confidence
Introduce Edge3 provider with new CLI, worker, and UI capabilities
The Edge provider is renamed to Edge3 and now requires Apache Airflow 3.0.0+. This location introduces the core Edge3 CLI commands (worker, status, maintenance, stop, list-workers), the EdgeWorker runtime with async API client and signal-based status/maintenance handling, and the React UI plugin for managing edge workers (including queue management, state filtering, and maintenance mode). It also adds example DAGs for integration testing and Windows worker interaction.
providers/edge3 · high confidence
Introduce Gantt chart view for DAG run details
A new Gantt chart visualization is now available in the DAG run details layout, providing a timeline-based view of task execution. The implementation includes the main Gantt component, a virtualized timeline renderer for performance, and utility functions for transforming task instance data into visual segments. The view supports displaying all task tries, handling mapped tasks and task groups as aggregate bars, and showing queued/scheduled states. It integrates with the existing grid view for synchronized scrolling and hover states, and includes comprehensive tests for the timeline rendering and data transformation logic.
airflow-core/src/airflow/ui/src/layouts/Details/Gantt · high confidence
Introduce Go SDK with native task authoring and self-contained bundle packaging
This change adds the Apache Airflow Go Task SDK, enabling users to write task functions in Go with native access to Airflow model objects (Variables, Connections, XComs) instead of Python. The SDK provides a \Bundle\ API for registering task handlers and a self-contained executable bundle format, packaged via the \airflow-go-pack\ tool, which embeds source files and metadata in a footer appended to the binary. It includes a pre-commit configuration for Go-specific linting and formatting, and establishes the foundational architecture for running Go tasks via the Task Execution Interface.
go-sdk · high confidence
Introduce Historical Metrics section on the Dashboard
The Dashboard now includes a new Historical Metrics section that displays aggregated counts for DAG runs and task instances over a selected date range. This area visualizes state distributions (such as success, failed, running, and queued) using proportional bars, with percentages hidden when counts are lower bounds to avoid misleading precision. Users can click on specific states to navigate to filtered lists of DAG runs or task instances, and the view includes an Asset Events panel alongside the metrics. The component supports auto-refreshing to keep data current and handles loading states with skeletons.
airflow-core/src/airflow/ui/src/pages/Dashboard/HistoricalMetrics · high confidence
Introduce Human-in-the-Loop (HITL) review modal for required actions
The HITLReview component area now provides a new modal interface for managing task required actions. This includes a list view that displays pending and completed HITL details (with filtering support), a detail summary showing DAG, task, and timing information, and a response form for submitting actions. A route-sync hook allows the modal to be opened via the '/required\_actions' URL path and closed by navigating away, while selection logic handles row selection and sequential navigation through the list.
airflow-core/src/airflow/ui/src/components/HITLReview · high confidence
Introduce IBM Db2 provider with hook and dialect support
This change adds the \apache-airflow-providers-ibm-db2\ package (version 0.1.0), introducing a new \Db2Hook\ and \Db2Dialect\ for connecting to IBM Db2 databases. The hook constructs connection strings and SQLAlchemy URIs, supporting extra parameters like SSL configuration and authentication types. The dialect provides Db2-specific SQL generation, including a \MERGE\ statement for upsert operations and logic to exclude identity columns when retrieving table metadata. The provider requires Apache Airflow 2.11.0 or later.
providers/ibm/db2 · high confidence
Introduce Informatica provider with automatic SQL lineage and selective control
The new Informatica provider enables automatic SQL lineage detection for tasks with a \\sql\\ attribute by parsing SQL at pre-execution time, resolving table references against the Informatica Enterprise Data Catalog (EDC), and creating lineage links on success. Users can disable auto-lineage globally via the \\\[informatica\] listener\_disabled\\ config, exclude specific operator classes using \\\[informatica\] disabled\_for\_operators\\, or selectively disable lineage for individual tasks or entire DAGs using the \\disable\_informatica\_lineage\\ helper. The provider also supports strict pre-execution validation via \\validate\_informatica\_lineage\\ to fail tasks early if lineage URIs cannot be resolved in the EDC catalog.
providers/informatica · high confidence
Introduce Java SDK annotation processor for DAG generation
Added the AirflowProcessor, a new Java annotation processor that generates builder and dependency-wiring classes for DAGs defined with @Airflow.Dag and @Airflow.Task annotations. This enables native Java developers to define Airflow DAGs using Java code, with the processor handling the generation of task dependencies, argument binding, and XCom forwarding at compile time.
processor · high confidence
Introduce Java SDK for defining and executing Airflow Dags
The Java SDK adds a new capability to define and execute Airflow Dags using Java and Kotlin. Users can now create Dags programmatically via the \DagDef\ class or through annotation-processed builders (\@Builder.Dag\), register tasks and task groups, and wire dependencies using \TaskRef\ handles with \before\/\after\ methods. The SDK supports complex control flow including conditional branching (\ConditionTask\), switching (\SwitchTask\), triggering other Dags (\TriggerDagRun\), and grouping tasks (\TaskGroupRef\). It also handles task input binding from Python stubs via \InputTask\ and \TaskInput\, manages Dag execution through the \Server\ entry point, and bundles Dags for serialization and transmission to the Airflow coordinator.
java-sdk/sdk · high confidence
Introduce Java SDK for defining and executing Airflow Dags
The Java SDK adds a new capability to define and execute Airflow Dags using Java and Kotlin. Users can now create Dags programmatically via the \DagDef\ class or through annotation-processed builders (\@Builder.Dag\), register tasks and task groups, and wire dependencies using \TaskRef\ handles with \before\/\after\ methods. The SDK supports complex control flow including conditional branching (\ConditionTask\), switching (\SwitchTask\), triggering other Dags (\TriggerDagRun\), and grouping tasks (\TaskGroupRef\). It also handles task input binding from Python stubs via \InputTask\ and \TaskInput\, manages Dag execution through the \Server\ entry point, and bundles Dags for serialization and transmission to the Airflow coordinator. Also in this area: Java SDK annotation namespace renamed from Builder to Airflow; Build-time warnings for invalid Dag and task IDs; Introduce Java SDK for native task development.
sdk · high confidence
Introduce Keycloak Auth Manager provider
This release introduces the \apache-airflow-providers-keycloak\ package (version 0.11.1), which enables Apache Airflow to use Keycloak as its authentication and authorization manager. The provider includes a \KeycloakAuthManager\ implementation that handles user sessions, integrates with Keycloak for login and logout flows, and enforces team-scoped authorization. It provides a CLI (\airflow keycloak\) to provision necessary resources, scopes, and permissions in Keycloak, and supports multiple token grant types (password, client credentials, and JWT-bearer) via a dedicated token API.
providers/keycloak · high confidence
Introduce common messaging provider with unified MessageQueueTrigger
The new \apache-airflow-providers-common-messaging\ package provides a unified \MessageQueueTrigger\ that abstracts away provider-specific details, allowing users to monitor message queues from different providers (such as SQS or Kafka) with a single trigger interface. This trigger supports both scheme-based matching (e.g., 'sqs', 'kafka') and legacy queue-URI-based matching, automatically routing to the correct provider implementation. The package also includes a \BaseMessageQueueProvider\ abstract class for defining new provider integrations and deprecation warnings for the old \queue\ parameter in favor of the new \scheme\ parameter.
providers/common/messaging · high confidence
Introduce common-compat provider for Airflow 2.x/3.x compatibility
The new \apache-airflow-providers-common-compat\ provider (version 1.21.0) establishes a shared compatibility layer that allows other providers to run on both Airflow 2.11+ and Airflow 3.x. It enforces a minimum Airflow version of 2.11.0 and provides backward-compatible imports for core concepts such as Assets (renamed from Datasets), BaseNotifier, and module loading utilities. The package also includes specific polyfills and helpers to bridge API changes, including asynchronous connection and hook retrieval, lineage \add\_extra\ support, OpenLineage version checks, and a \ChainRetryPolicy\ for Airflow 3.3.
providers/common/compat · high confidence
Introduce consolidated E2E test harness with multi-language SDK support
The airflow-e2e-tests directory now provides a unified end-to-end testing framework built on testcontainers, enabling validation of native DAGs and task stubs across TypeScript, Java, and Go SDKs. This change introduces dedicated Docker Compose configurations and runtime environments for each language (including Node.js for TypeScript, a headless JRE for Java, and static binaries for Go), alongside infrastructure services like LocalStack (S3), Elasticsearch, OpenSearch, and Kafka to support remote logging, XCom object storage, and event-driven DAG testing. It also includes a test fixture bundle for validating Java runner behavior and specific configurations for OpenLineage compatibility matrices.
airflow-e2e-tests · high confidence
Introduce execution API datamodels for runtime communication
This change adds the Pydantic data models that define the request and response schemas for the Airflow execution API, which workers use to interact with the scheduler. The new models cover asset state and events (including partition keys), DAG run triggers (supporting run\_after, partition\_key, and note), connection testing results, variable management, and XCom access (including sequence slicing). These schemas standardize the data structures exchanged between the execution environment and the control plane. Also in this area: Scoped Dag processor access and task queued duration metric.
_airflow-core/src/airflow/api\_fastapi/execution\api/datamodels · high confidence
Introduce folder-based DAG grouping and navigation
The Dags page now organizes DAGs into a hierarchical folder tree, allowing users to group and filter DAGs by their directory structure. The new DagFolderTree component renders nested folders, automatically synthesizing intermediate parent directories that do not contain DAGs directly, and supports multi-bundle environments by keeping folder selections distinct across different bundles. Users can expand and collapse folders, with the tree automatically expanding to reveal the currently selected folder, and long folder names are truncated with tooltips to maintain layout stability.
airflow-core/src/airflow/ui/src/pages/DagsList/DagFolderTree · high confidence
Introduce local API client for programmatic Airflow interaction
A new local API client module has been added to the core package, providing a \Client\ class that wraps internal Airflow functions for triggering DAGs, deleting DAGs, and managing pools. This client enables programmatic interaction with the Airflow scheduler and metadata database without requiring a remote HTTP connection, supporting features such as specifying a triggering user name for DAG runs and managing pool attributes like team names.
airflow-core/src/airflow/api/client · high confidence
Introduce providers\_discovery package with public API exports
The \shared/providers\_discovery\ module is now available as a public package, exposing key classes and utilities such as \HookClassProvider\, \HookInfo\, \PluginInfo\, \ProviderInfo\, and discovery functions like \discover\_all\_providers\_from\_packages\. This change centralizes provider discovery logic and makes these components accessible for external use or integration within the Airflow ecosystem.
_shared/providers\discovery · high confidence
Introduce shared observability package with unified metrics and tracing infrastructure
The \shared/observability\ package consolidates Airflow's metrics and tracing logic into a single, reusable library. It introduces a central metrics registry (YAML-backed) that supports legacy name emission and validates metric names, while providing unified logging backends for StatsD, Datadog, and OpenTelemetry. The package also adds OpenTelemetry environment variable support for configuring exporters, IPv6 host bracketing for endpoints, and fork-safe backend initialization to ensure metrics are correctly reported in child processes.
shared/observability · high confidence
Introduce static site generator for the Provider Registry
The Provider Registry is now built as a static site using Eleventy, replacing the previous implementation. This change introduces a new build pipeline that extracts provider metadata, module definitions, and connection details into JSON data files, which are then rendered into HTML. The site includes a search index powered by Pagefind, an API Explorer with vendored Swagger UI, and filters for formatting download counts and sorting module types. Configuration files for the build process, including Eleventy settings, pnpm workspace overrides, and font licenses, are now part of the repository.
registry · high confidence
Introduce the Java SDK for authoring Airflow workflows in JVM languages
This change adds the Java SDK, a new JVM-based interface for Apache Airflow that allows users to author and execute workflow bundles using Java or Kotlin. The SDK enables native Dag authoring via annotations (e.g., \@Builder.Dag\, \@Builder.Task\) and supports mixed-language scenarios where Java tasks can be bound to Python \@task.stub\ definitions. It includes a Gradle-based build system, a capability manifest defining supported features (such as XComs, Variables, and task state stores), and architectural design records detailing the interface contracts for both native and mixed-language Dag execution. Also in this area: Build-time warnings for invalid Dag and task IDs.
java-sdk, java-sdk/plugin · high confidence
Introduce the common.ai provider with TaskFlow decorators and batch execution support
The new \apache-airflow-providers-common-ai\ provider (version 0.11.0) introduces a suite of TaskFlow decorators (\@task.llm\, \@task.agent\, \@task.llm\_batch\, \@task.llm\_branch\, \@task.llm\_file\_analysis\) that allow users to wrap Python functions directly into LLM-driven Airflow tasks. This location specifically provides the batch execution framework, including a dispatch system and adapters for OpenAI and Anthropic, enabling bulk asynchronous LLM calls. The provider also enforces a minimum Apache Airflow version of 2.11.0.
providers/common/ai · high confidence
Introduction of the FastAPI-based API server implementation
The API server location now contains the core implementation files for the new FastAPI-based API server, including the main application factory (app.py), the entry point (main.py), and Gunicorn integration modules (gunicorn\_app.py, gunicorn\_config.py). This change introduces the structural foundation for the API server, including lifespan management for stats initialization, Gunicorn worker monitoring for rolling restarts, and compatibility shims for HTTP status codes to ensure backward compatibility with older Starlette versions.
_airflow-core/src/airflow/api\fastapi · high confidence
Java SDK introduces AirflowJulHandler to route JUL logs to Airflow
The Java SDK now includes the \AirflowJulHandler\ component, which allows Java applications using java.util.logging (JUL) to send their log records directly to the Airflow task log store. By calling \AirflowJulHandler.setup()\, users can replace or augment the root logger's handlers, ensuring that JUL messages are converted to SDK levels and transmitted via the \Log\ pipeline, including exception details. This change provides a standardized way to integrate standard Java logging into Airflow's observability without manual configuration of external providers.
java-sdk/jul · high confidence
Java SDK now supports routing logs from SLF4J, Log4j2, and JDK System.Logger to Airflow
The Java SDK now includes dedicated logging providers for SLF4J, Log4j2, and the JDK's built-in System.Logger, allowing applications using these frameworks to have their logs automatically forwarded to the Airflow task log store. This change introduces the AirflowSlf4jProvider, AirflowLog4jAppender, and AirflowSystemLoggerFinder components, which map standard logging levels to Airflow's internal log levels and ensure that log messages, exceptions, and markers are captured in the Airflow UI.
java-sdk/jpl, java-sdk/log4j2, java-sdk/slf4j · high confidence
Keyboard navigation for the Grid view
Users can now navigate the Grid view using keyboard arrow keys. This change introduces a new navigation hook that detects the current view mode (Run, Task, or Task Instance) and allows moving between runs (left/right) and tasks (up/down) via the keyboard, automatically focusing the newly selected grid element to maintain accessibility.
airflow-core/src/airflow/ui/src/hooks/navigation · high confidence
Keyboard shortcuts for marking DAG runs as success or failed
The Mark As Run UI component now supports keyboard shortcuts to quickly mark a DAG run as successful or failed. Users can trigger these actions via the configured hotkeys (enabled by default), which open the confirmation dialog with the corresponding state pre-selected, streamlining the workflow for common state changes.
airflow-core/src/airflow/ui/src/components/MarkAs/Run · high confidence
Manage XComs directly from the UI
The XComs page now allows you to add, edit, and delete XCom entries directly from the interface. A new Add button opens a modal to create entries, while Edit and Delete buttons on each row let you modify or remove existing values. The page also includes a FilterBar for filtering by key, date ranges, and other parameters, and displays XCom values with hyperlink support for URLs.
airflow-core/src/airflow/ui/src/pages/XCom · high confidence
Mark task groups as success or failed
Users can now change the state of an entire task group directly from the DAG details view. A new button in the action menu opens a dialog that lets you select the target state (success or failed) and choose whether to include past, future, upstream, or downstream tasks. The dialog provides a dry-run preview of affected tasks and supports keyboard shortcuts for quick marking.
airflow-core/src/airflow/ui/src/components/MarkAs/TaskGroup · high confidence
Microsoft Azure provider version 15.2.1 with Airflow 2.11+ requirement
The Microsoft Azure provider has been updated to version 15.2.1, which now requires Apache Airflow 2.11.0 or later. This release introduces new capabilities including Azure AI Foundry Hosted Agents support, Azure Analysis Services model refresh, and a Microsoft Graph filesystem integration, alongside various bug fixes and compatibility updates for the Task SDK.
providers/microsoft/azure · high confidence
New 'Mark As' UI component for changing task and run states
The UI now includes a new 'Mark As' component that provides buttons to change the state of DAG runs, task groups, and individual task instances. This change introduces the underlying logic and UI controls for actions such as marking a task instance as skipped (available for scheduled, up\_for\_reschedule, and up\_for\_retry states) or marking DAG runs and task groups as success or failed, enabling users to manually adjust execution states directly from the interface.
airflow-core/src/airflow/ui/src/components/MarkAs · high confidence
New AWS Auth Manager with Amazon Verified Permissions support
The Amazon provider now includes a new \AwsAuthManager\ that enables authentication via Amazon Identity Center (SSO) and fine-grained authorization using Amazon Verified Permissions (AVP). This feature introduces a complete auth manager implementation, including SAML login routes, a CLI for initializing AVP policy stores and schemas, and a Cedar policy schema defining permissions for Airflow resources like DAGs, assets, connections, and variables. It requires Airflow 3.0+ and the optional \python3-saml\ library.
providers/amazon · high confidence
New ActionAccordion component for task instance actions
The UI now includes a new ActionAccordion component that displays affected task instances in a table with optional row selection checkboxes, allowing users to exclude specific tasks from bulk actions. The component supports grouping task instances by DAG run ID when multiple runs are involved, and includes an editable markdown note field for action descriptions.
airflow-core/src/airflow/ui/src/components/ActionAccordion · high confidence
New Airflow UI pages for Jobs, Providers, Plugins, and external views
The Airflow UI now includes dedicated pages for browsing Jobs, Providers, and Plugins, each rendered as a data table with filtering and sorting capabilities. The Jobs page adds a team column and filter when multi-team is enabled. External views (including legacy FAB views and React app plugins) are now rendered inside iframes with URL synchronization, allowing deep-linking and navigation mirroring. A new Error page handles route errors and 404s with a back/home navigation. The Landing page respects the user's default landing page setting (Dashboard or Dags). The Security page embeds auth manager views in an iframe with path validation to prevent navigation outside the auth area.
airflow-core/src/airflow/ui/src/pages · high confidence
New Asset details page with interactive graph and event management
The UI now includes a dedicated Asset details page that provides an interactive dependency graph (supporting both scheduling and data dependency views), a sortable and filterable asset events table, and the ability to manually create asset events or materialize assets via a modal. The layout features a split view with the graph on the left and asset metadata (including aliases, watchers, and extra data) on the right, along with navigation tabs for events and the asset state store.
airflow-core/src/airflow/ui/src/pages/Asset · high confidence
New Clear Run dialog with configurable options and keyboard shortcuts
The UI now provides a dedicated Clear Run dialog for DAG runs, allowing users to select between clearing existing tasks, only failed tasks, or queuing new tasks. This dialog supports adding a note to the clear operation and includes a 'Run on latest version' checkbox when applicable. It also integrates with the global keyboard shortcut system, enabling users to open the dialog via a hotkey.
airflow-core/src/airflow/ui/src/components/Clear/Run · high confidence
New Dag Version Comparison tab
A new UI tab on the Dag details page allows users to select two stored Dag versions and view a structured diff of their changes. The comparison table displays the path, operation, category, and impact of each change, and shows the actual before/after values when the user has code access. Users can control the maximum number of changes returned via a new input field (defaulting to 500, capped at 5000) to manage performance, and the UI clearly indicates when the result was truncated by this limit.
airflow-core/src/airflow/ui/src/pages/Dag/Versions · high confidence
New Dags list UI components and bulk scheduling controls
The Dags list page now includes a folder tree for grouping and filtering Dags by bundle and directory, a redesigned Dag card that progressively loads interactive elements and displays asset schedules, run state counts, and recent task states, and new bulk action buttons for pausing, draining, and unpausing multiple Dags at once. These changes improve navigation, provide richer scheduling context, and enable efficient batch management of DAG states.
airflow-core/src/airflow/ui/src/pages/DagsList · high confidence
New DagsFilters component with multi-team and preset filter support
The DagsList page now uses a dedicated DagsFilters component that consolidates filtering logic into a FilterBar. This component supports standard filters (paused, scheduling state, run state, tags, owners, timetable type, favorite) and conditionally adds a team filter when the multi\_team configuration is enabled. It also introduces preset filters and ensures the paused filter respects the hide\_paused\_dags\_by\_default setting by displaying it as an active pill rather than hiding it invisibly. Tests confirm that filters are correctly applied, removed, and restored from URL parameters, and that the team filter only appears when multi-team mode is active.
airflow-core/src/airflow/ui/src/pages/DagsList/DagsFilters · high confidence
New DataTable component with card view, multi-column sort, and column visibility controls
The Airflow UI introduces a new \DataTable\ component in \airflow-core/src/airflow/ui/src/components/DataTable\ that replaces the previous table implementation. This component adds a card display mode (toggled via \ToggleTableDisplay\) alongside the standard table view, supports multi-column sorting when \enableMultiSort\ is enabled (allowing shift-click to add secondary sorts), and lets users hide or show columns via a \FilterMenuButton\ with visibility preferences persisted in \localStorage\. The component also integrates with URL search parameters to maintain sort and pagination state across page reloads, and includes comprehensive unit tests for state changes, column visibility, and i18n model name keys.
airflow-core/src/airflow/ui/src/components/DataTable · high confidence
New Events page for viewing audit logs
The UI now includes a dedicated Events page (located at \src/pages/Events\) that displays audit log entries in a sortable, filterable table. Users can filter events by date range, event type, user, map index, try number, and team (if multi-team is enabled), with additional context-specific filters for DAG, run, and task IDs when viewed outside a specific task context. The table shows event time, type, owner, team, and extra JSON details, and supports URL-based state persistence for filters and sorting.
airflow-core/src/airflow/ui/src/pages/Events · high confidence
New FilterBar filter components for boolean, date, date range, number, multi-select, run state, and select types
The FilterBar now includes a comprehensive set of new filter components (BooleanFilter, DateFilter, DateRangeFilter, NumberFilter, MultiSelectFilter, RunStateFilter, SelectFilter) that allow users to filter DAG runs and task instances by boolean flags, specific dates, date ranges with calendar selection, numeric values, multiple selections with match modes, run states with time lookbacks, and single selections. These components provide a unified pill-based UI for adding, editing, and removing filters across list pages.
airflow-core/src/airflow/ui/src/components/FilterBar/filters · high confidence
New Graph view component with task filtering and export capabilities
The DAG details page now uses a new Graph component that supports filtering nodes by operator, state, task group, duration, and map index, while also allowing users to export the flowchart as an image and zoom to specific tasks.
airflow-core/src/airflow/ui/src/layouts/Details/Graph · high confidence
New Group Task Instance page with loop iteration and outcome details
The UI now includes a dedicated Group Task Instance page that displays a header with group-level outcome statistics (such as loop status, iteration counts, and exit criteria), start/end dates, and duration. For loop groups, users can filter the task list by specific loop iterations or view all iterations using a new IterationSelect component, which also handles stale iteration parameters and loop region selection. The page integrates with the existing TaskInstances view and supports actions like clearing the task group or marking it as success/failed.
airflow-core/src/airflow/ui/src/pages/GroupTaskInstance · high confidence
New Mapped Task Instance page with Details tab and Clear All button
The Mapped Task Instance view now includes a dedicated Details tab that displays the overall status, per-state counts, task metadata (operator, trigger rule, owner, retries, pool, queue, priority weight, depends\_on\_past, wait\_for\_downstream), and duration. The header card shows the task display name with the mapped task count, start/end dates, and duration, and includes a 'Clear All Mapped Tasks' button to clear all mapped instances at once. The page uses a streamed grid task-instance summary to keep the view updated in real-time.
airflow-core/src/airflow/ui/src/pages/MappedTaskInstance · high confidence
New TypeScript SDK examples demonstrating native DAGs, human-in-the-loop workflows, and dynamic Dag generation
The \ts-sdk/example\ directory now includes a comprehensive set of TypeScript examples that showcase the SDK's capabilities. These include \native.ts\, which defines a fully native DAG with task groups, conditional logic, and multi-way branching; \hitl.ts\, which demonstrates human-in-the-loop patterns for approvals, timeouts, and form inputs; \ai-approval.ts\, which integrates AI agent tool calls with human review; \dynamic.ts\, which generates DAGs from a YAML configuration file; and \taskflow.ts\, which provides handlers for mixed-language DAGs with argument binding. These examples serve as practical references for building complex, type-safe workflows in TypeScript.
ts-sdk/example · high confidence
New UI API data models for Airflow 3 interface
This change introduces a comprehensive set of Pydantic data models in the \airflow/api\_fastapi/core\_api/datamodels/ui\ package, defining the response structures for the new Airflow 3 UI. These models support specific UI features including the Grid view (with loop and mapped task details), Gantt chart, Calendar view, Asset graph, and Dashboard. Key additions include team support in multi-team mode, deadline tracking, partitioned DAG run status, and self-service JWT token generation, providing the necessary schema for the frontend to render these interfaces.
_airflow-core/src/airflow/api\_fastapi/core\api/datamodels/ui · high confidence
New UI components for error handling, search, and navigation
The UI introduces several new components to improve error visibility, search capabilities, and navigation structure. ActionErrors now displays bulk action failures alongside generic errors, while DAGWarningsModal and DagDeactivatedBanner surface import errors and stale DAG states with detailed stack traces. AdvancedSearchToggle adds a regex-based 'match anywhere' search option, and the new Breadcrumb system (Crumb, CrumbSwitcher, Row) provides a structured, chevron-styled navigation bar with state indicators. Additional components like AnsiRenderer for colored logs, AssetProgressCell for asset dependencies, and ConfigForm for JSON configuration further enhance the user experience.
airflow-core/src/airflow/ui/src/components · high confidence
New UI hooks for search, navigation, and interaction logic
The \airflow/ui/src/hooks\ directory now includes a suite of new React hooks that power specific UI behaviors. \useAdvancedSearch\ and \useMatchMode\ manage per-searchbar 'match anywhere' toggles and any/all match modes, persisting choices in the URL and localStorage. \useDagRunsLimit\ remembers the Dag runs limit per Dag across tab switches. \useDateRangeFilter\ handles date/time input validation and timezone-aware formatting. \useHITLReviewTabs\ manages Human-in-the-loop review session discovery and tab visibility. \useIframeUrlSync\ synchronizes iframe navigation with the browser URL for deep-linking. \useNearViewport\ implements deferred loading of interactive elements using IntersectionObserver. \usePluginAppliesToContext\ handles scoping plugin views to specific entities. \useCalendarSelect\ provides calendar day generation, and \useLoopRuleStats\ displays loop iteration stats.
airflow-core/src/airflow/ui/src/hooks · high confidence
New UI service layer for Grid, Calendar, and Dependency views
The UI API backend now uses a dedicated service layer in \airflow/api\_fastapi/core\_api/services/ui\ to power the Grid, Calendar, and Dependency views. This introduces a \CalendarService\ that supports partitioned DAGs, displays backfill status, and fixes cron planned-run calculation to respect the DAG's timezone. The Grid view logic now aggregates task instances to show loop iterations, DAG version changes, and saved notes, while also fixing crashes when tasks are converted to TaskGroups and improving response times. Additionally, a \HookMetaService\ allows connection form metadata to load from YAML without requiring the FAB provider, and dependency graph services consolidate asset and scheduling dependency logic with proper permission filtering.
_airflow-core/src/airflow/api\_fastapi/core\api/services/ui · high confidence
New auth manager model interfaces and request types
The auth manager models package now defines the \BaseUser\ interface, which includes a new \get\_display\_name\ method that defaults to the user's name for backward compatibility, alongside existing \get\_id\ and \get\_name\ methods. Additionally, the package introduces \batch\_apis.py\ containing TypedDict definitions for authorization requests (\IsAuthorizedConnectionRequest\, \IsAuthorizedDagRequest\, \IsAuthorizedPoolRequest\, \IsAuthorizedVariableRequest\), establishing the data structures used by the auth manager's API.
_airflow-core/src/airflow/api\fastapi/auth/managers/models · high confidence
New example DAGs for Assets, Asset Aliases, and Partitioning
The example DAGs in the \airflow-core\ package have been expanded to demonstrate the new Asset ecosystem. New examples include \example\_asset\_alias\ and \example\_asset\_alias\_with\_no\_taskflow\ to show conditional and expression-based scheduling via AssetAliases, \example\_asset\_allow\_teams\ to illustrate cross-team asset triggering with \AssetAccessControl\, and \example\_asset\_partition\ to demonstrate multi-asset partition alignment using mappers like \StartOfHourMapper\ and \ProductMapper\. Additional examples cover \example\_asset\_state\_store\ for watermark tracking, \example\_asset\_with\_watchers\ for event-driven file polling, and \example\_asset\_decorator\ for decorator-based asset definitions.
_airflow-core/src/airflow/example\dags · high confidence
New example plugins for custom partition mappers, windows, timetables, and listeners
The example DAGs now include a set of plugin implementations that demonstrate how to extend Airflow without modifying core code. These examples show how to register custom partition mappers (e.g., stripping namespace prefixes), custom Window subclasses for asset partitions (e.g., business-day-only month rollups), custom timetables (e.g., cron schedules with runtime partitioning or workday-aware scheduling), custom priority weight strategies, and event listeners for task and DAG run state changes.
_airflow-core/src/airflow/example\dags/plugins · high confidence
New listener hook specifications for assets, DAG runs, and import errors
The \airflow/listeners\ module now exposes formal hook specifications for key lifecycle events, allowing plugins and integrations to react to specific system changes. New hooks include \on\_asset\_created\, \on\_asset\_alias\_created\, \on\_asset\_changed\, and \on\_asset\_event\_emitted\ for asset tracking; \on\_dag\_run\_running\, \on\_dag\_run\_success\, and \on\_dag\_run\_failed\ for DAG run state transitions; and \on\_new\_dag\_import\_error\ and \on\_existing\_dag\_import\_error\ for DAG import failures. These specs are registered by the core \ListenerManager\ alongside existing lifecycle and task instance hooks, providing a standardized interface for external listeners.
airflow-core/src/airflow/listeners · high confidence
New partition mapper and window types for asset-driven DAGs
The \airflow.partition\_mappers\ package now exposes a comprehensive set of new classes for mapping asset partitions to DAG run partitions. This includes \RollupMapper\ for aggregating upstream keys, \FixedKeyMapper\ for categorical rollups, \ProductMapper\ for multi-dimensional keys, and \ChainMapper\ for sequential mapping. Temporal mapping is supported via \FanOutMapper\ and a family of \StartOf\*Mapper\ classes (e.g., \StartOfDayMapper\), paired with corresponding \Window\ types (e.g., \DayWindow\, \SegmentWindow\). Additionally, \AllowedKeyMapper\ is available for key validation, and \IdentityMapper\ for passthrough, all standardized with \WaitForAll\ and \MinimumCount\ wait policies.
_airflow-core/src/airflow/partition\mappers · high confidence
New performance testing framework with configurable DAG generation
The performance area now includes a dedicated testing framework that generates configurable DAGs to measure Airflow performance. Users can control the number of DAGs, tasks, and DAG structure (linear, binary tree, star, grid, or no structure) via environment variables such as PERF\_DAGS\_COUNT, PERF\_TASKS\_COUNT, and PERF\_SHAPE. The framework supports different operator types (bash, python, big\_query\_insert\_job) and includes pre-defined workflow configurations for scenarios like blocking, scheduling, and worker tasks. This change introduces the core logic for generating these test DAGs and the associated utilities and tests within the performance package.
performance · high confidence
New providers summary documentation site
A new documentation site for Apache Airflow providers has been added, providing a centralized index of community-managed providers and their capabilities. This includes a configuration file for building the documentation with Sphinx, a main index page, and dedicated sections detailing core extensions such as auth managers, CLI commands, custom connections, executors, secret backends, and email backends. It also contains a how-to guide for creating custom providers, explaining the provider metadata schema and entry points.
providers-summary-docs · high confidence
New reusable FilterBar component for consistent list-page filtering
The UI introduces a new \FilterBar\ component in \airflow-core/src/airflow/ui/src/components/FilterBar\ to unify filtering across list pages. This component supports multiple filter types—including boolean, text, number, date, date range, select, and multiselect—and renders active filters as interactive pills that can be edited or removed. It handles synchronization with URL query parameters, supports custom editor components for complex filtering logic, and includes a preset filters menu. The implementation includes comprehensive unit tests to verify behavior for adding, updating, and clearing filters, as well as handling of initial values and edge cases like empty arrays or invalid states.
airflow-core/src/airflow/ui/src/components/FilterBar · high confidence
New shared API server utilities for pagination, error handling, and access logging
The \airflow.api\_fastapi.common\ package introduces a set of shared utilities for the API server. It adds cursor-based (keyset) pagination helpers in \cursors.py\ to support efficient, index-friendly pagination for endpoints like \get\_dag\_runs\ and \get\_task\_instances\. A new exception handling framework in \exceptions.py\ centralizes database and DAG deserialization errors, introducing a configurable \expose\_stacktrace\ setting to hide sensitive SQL details from API responses by default. The package also includes an HTTP access log middleware (\http\_access\_log.py\) that redacts secret-looking query parameters and uses structured logging, and utility modules for managing a shared, cached \DagBag\ instance, redacting asset expressions based on user permissions, and parsing HTTP headers.
_airflow-core/src/airflow/api\fastapi/common · high confidence
New shared secrets masking module
A new \airflow\_shared.secrets\_masker\ module has been introduced to centralize the redaction of sensitive information from logs. This module provides a \SecretsMasker\ class and utility functions (such as \mask\_secret\, \redact\, and \merge\) that automatically hide values associated with sensitive field names (e.g., \password\, \api\_key\, \access\_token\) defined in \DEFAULT\_SENSITIVE\_FIELDS\. It supports recursive redaction of nested structures and includes logic to handle Kubernetes environment variables without requiring unnecessary imports, ensuring that credentials and other secrets are consistently masked across the Airflow codebase. Also in this area: 1 commit (1 fix) fixing shared/secrets\_masker.
_shared/secrets\masker · medium confidence · unverified
New state store backend for task and asset state persistence
The \airflow.state\ module now provides a new backend abstraction for persisting task and asset state, with a default \MetastoreBackend\ that stores this data in the Airflow metadata database. This change introduces a configurable state store (via \state\_store.backend\) that allows operators to define custom backends, while the default implementation handles CRUD operations for task and asset scopes using SQLAlchemy upserts and dialect-specific logic for PostgreSQL, MySQL, and SQLite.
airflow-core/src/airflow/state · high confidence
New system component library for the Airflow UI
The Airflow UI now includes a new set of reusable system components in the \system-components\ directory, providing standardized building blocks for the interface. This release introduces components for Accordion, Action Bar, Alerts, Button Group Toggles, Checkboxes, Clipboard operations, Dialogs, Modals, Menus, and Number Inputs, all built on top of Chakra UI. These components are designed to offer consistent styling and behavior across the application, with features like localized number formatting and accessible interactions.
airflow-core/src/airflow/ui/src/system-components · high confidence
New user settings page for UI defaults
A new Settings page has been added to the Airflow UI, allowing users to configure persistent browser-based preferences for their experience. This includes options to set the default landing page, graph direction, and whether task groups are expanded by default. Users can also control search behavior with a 'match anywhere' toggle, adjust DAG list display to show recent tasks, and define defaults for task clearing and marking actions (such as preventing the clearing of running tasks or keeping task state). These settings are stored in local storage and persist across sessions.
airflow-core/src/airflow/ui/src/pages/Settings · high confidence
OpenAI provider v2.1.0 requires Airflow 2.11+ and introduces Managed Agents and Responses API support
The OpenAI provider has been restructured and upgraded to version 2.1.0, which now requires Apache Airflow 2.11.0 or later. This release adds new capabilities including the \OpenAIAgentSessionOperator\ for interacting with OpenAI Managed Agents and the \OpenAIResponseOperator\ for the OpenAI Responses API. The provider also introduces Workload Identity authentication support, Pydantic structured outputs for responses, and improved error handling for batch jobs (distinguishing timeouts and cancellations). Existing Assistants API methods are now deprecated in favor of the new Responses and Conversations APIs.
providers/openai · high confidence
Oracle provider restructured for Airflow 3.0 with new asset and lineage support
The Oracle provider has been reorganized to support Airflow 3.0, introducing a new package structure and compatibility layer. Users can now leverage native Asset support for Oracle URIs, enabling automatic lineage tracking via OpenLineage and integration with the Airflow asset graph. The provider also includes updated hooks with improved LOB handling, new example DAGs for stored procedures and data fetching, and a minimum Airflow version requirement of 2.11.0.
providers/oracle · high confidence
Postgres provider v7.1.1 requires Airflow 2.11.0 and introduces native dialect and asset support
The postgres provider has been updated to version 7.1.1, which now enforces a minimum Apache Airflow version of 2.11.0. This release introduces a native PostgresDialect implementation that provides SQLAlchemy-independent methods for retrieving primary keys and column names, and adds support for Postgres asset URIs (postgres:// and postgresql://) with sanitization, asset creation, and OpenLineage conversion capabilities. The provider also registers its dialect and asset handlers in the provider info, enabling better integration with Airflow's asset and lineage systems.
providers/postgres · high confidence
React plugin template now supports system-aware dark mode
The React plugin template now includes a \ColorModeProvider\ and \useColorMode\ hook that leverage \next-themes\ to respect the user's system theme preference, in addition to allowing manual toggling between light and dark modes. The template's main component inherits the core UI theme via \ChakraProvider\ to ensure consistency with the host Airflow application, while falling back to a local Chakra system for standalone development.
_dev/react-plugin-tools/react\_plugin\template · high confidence
Redesigned DAG graph view with new node types and controls
The DAG graph view has been completely rewritten to use a new component architecture, introducing dedicated visual nodes for Assets, Asset Conditions (AND/OR gates), Aliases, and DAGs themselves, alongside the existing Task nodes. Users can now export the graph as a PNG image, change the graph direction (Left, Right, Up, Down) with per-graph persistence, and see a segmented state bar on collapsed task groups and mapped tasks to visualize child state distributions. The view also features improved edge rendering, better selection highlighting, and cleaner link handling for tasks across different run contexts.
airflow-core/src/airflow/ui/src/components/Graph · high confidence
Redesigned DAG run detail page with execution view and deadline tracking
The DAG run detail page has been restructured into a tabbed layout (Task Instances, Execution, Asset Events, Audit Log, Code, Details) to improve navigation and information density. A new Execution tab allows users to view and select specific task instances for clearing, while the Header now displays deadline status (met, missed, or upcoming) with a detailed modal for multiple instances. The Details tab has been expanded to include expected duration statistics (mean, mode, percentiles), partition date, triggering user name, and bundle version. Additionally, the page now supports partition key display and multi-team ownership visibility.
airflow-core/src/airflow/ui/src/pages/Run · high confidence
Redis provider v4.7.1 for Airflow 2.11+ with cluster, SSL, and PubSub support
The Redis provider has been updated to version 4.7.1, which now requires Apache Airflow 2.11.0 or later. This release introduces support for Redis Cluster mode in the connection hook, allowing users to configure startup nodes and cluster-specific settings via the connection UI. It also adds comprehensive SSL/TLS configuration options (certificates, verification modes, hostname checking) to the connection form. Additionally, the provider now includes a Redis Pub/Sub message queue integration, enabling the use of the \AwaitMessageTrigger\ for asynchronous workflows, and updates the \RedisTaskHandler\ to support log file size handling.
providers/redis · high confidence
SMTP provider v3.1.1: Async support, OAuth2 authentication, and new notifier
The SMTP provider has been updated to version 3.1.1, requiring Apache Airflow 2.11.0 or later. This release introduces asynchronous execution capabilities for both the SMTP hook and the new SmtpNotifier, allowing non-blocking email operations. It also adds OAuth 2 / XOAUTH2 authentication support via a new \auth\_type\ connection field, enabling integration with modern email services. The provider now includes a \SmtpNotifier\ class for task failure callbacks and updates the connection UI metadata to YAML-based discovery.
providers/smtp · high confidence
Snowflake provider v6.19.0 with new Cortex, Snowpark, and asset capabilities
The Snowflake provider has been updated to version 6.19.0, which now requires Apache Airflow 2.11.0 or later. This release introduces several new capabilities: a \SnowparkOperator\ and a \@task.snowpark\ decorator for running Snowpark code directly in tasks, a \SnowflakeCortexAgentHook\ and associated operators for managing and running Cortex Agents, and a \PydanticAISnowflakeHook\ to expose Snowflake Cortex's OpenAI-compatible chat endpoint as a Pydantic AI model. Additionally, the provider now supports Snowflake URIs as Airflow Assets, enabling asset-based data lineage and triggering for Snowflake tables, and adds support for Workload Identity Federation (WIF) for authentication.
providers/snowflake · high confidence
Standard provider version 1.20.1 with new TaskFlow decorators and example DAGs
The standard provider has been updated to version 1.20.1, which now requires Apache Airflow 2.11.0 or later. This release introduces a new \decorators\ module that provides TaskFlow-style decorators for standard operators, including \@task.bash\, \@task.python\, \@task.virtualenv\, \@task.external\_python\, \@task.branch\, \@task.branch\_external\_python\, \@task.branch\_virtualenv\, \@task.sensor\, \@task.short\_circuit\, and \@task.stub\. Additionally, the provider now includes a set of example DAGs in the \example\_dags\ directory to demonstrate the usage of these operators and decorators, such as \example\_bash\_decorator.py\ and \example\_bash\_operator.py\.
providers/standard · high confidence
Task SDK becomes a standalone distribution with native bundle support
The Task SDK is now a standalone Python package (\apache-airflow-task-sdk\) with its own repository structure, including dedicated \pyproject.toml\, pre-commit hooks, and documentation. This change decouples the SDK from the core Airflow package, allowing it to be installed and versioned independently. It also introduces support for native executable DAG bundles (e.g., Go, Java, TypeScript) via a new metadata schema (\airflow-metadata.schema.json\) and importer registry, enabling non-Python DAGs to be discovered and executed by the Airflow scheduler and workers.
task-sdk · high confidence
Task log viewer gains search, external links, and display toggles
The Task Instance Logs page now includes a search input that highlights matches and allows navigation between them, plus an external log link button that opens remote log storage in a new tab. Users can toggle the visibility of timestamps, log levels, and source details (logger and location) via a settings menu, with preferences saved in localStorage. The view also supports wrapping, fullscreen mode, and keyboard shortcuts for these controls, while the log download now includes the .txt extension and respects the current display filters.
airflow-core/src/airflow/ui/src/pages/TaskInstance/Logs · high confidence
Task overview now supports loop history charts and scoped React plugins
The Task Overview page now displays a Loop History Chart for loop groups, showing median iterations, cap hits, and a bar chart of iteration counts that allows users to click into specific nested invocations. Additionally, the overview now renders React plugins scoped to the task overview destination, filtering them by context (e.g., operator type) so that only relevant plugin content appears for the specific task being viewed.
airflow-core/src/airflow/ui/src/pages/Task/Overview · high confidence
Tasks page now supports filtering and searching
The Tasks view for DAGs now allows users to filter the task list by operator, trigger rule, and retry count, as well as search by task name. This is implemented via a new \TaskFilters\ component and a \DataTable\ that respects URL search parameters, with unit tests added to verify the filtering logic.
airflow-core/src/airflow/ui/src/pages/Dag/Tasks · high confidence
Teradata provider restructured for Airflow 2.11+ with new operators and asset support
The Teradata provider has been restructured to require Apache Airflow 2.11.0 and now includes new operators for executing BTEQ scripts (BteqOperator), Teradata Parallel Transporter (TptOperator), and Data Definition Language statements (DdlOperator). The provider also introduces support for Airflow Assets with teradata:// URI schemes, enabling asset-based data lineage and integration with the OpenLineage ecosystem. Connection handling has been updated to use the new Task SDK BaseOperator, and the provider metadata is now defined via YAML configuration.
providers/teradata · high confidence
Variables page receives bulk delete and import capabilities
The Variables page now supports bulk deletion and importing of variables directly from the UI. Users can select multiple variables and delete them in a single action via a confirmation modal, and can import variables from a JSON file with options to handle conflicts (fail, overwrite, or skip). These features are implemented through new components (DeleteVariablesButton, ImportVariablesButton, ImportVariablesForm) integrated into the main Variables list page.
airflow-core/src/airflow/ui/src/pages/Variables · high confidence
Visualize asset dependency expressions in the UI
The UI now renders asset expressions (AND/OR logic) for DAGs using new components (AssetExpression, AndGateNode, OrGateNode, AssetNode). Users can see how assets and aliases are combined, with visual indicators for received, partial, or pending asset events, including rollup key checklists and partitioned DAG run status.
airflow-core/src/airflow/ui/src/components/AssetExpression · high confidence
Removals
Removal of core Airflow components
The core module has been completely removed, deleting all files including the CLI entry point (flux.py), the DAG execution models (DagBag, TaskInstance, DAG), the operator and hook implementations (BashOperator, MySqlOperator, MySqlHook), the executor infrastructure (LocalExecutor, SequentialExecutor), and supporting utilities (settings, utils, macros).
core · high confidence
Removal of legacy Flask-based web interface
The previous Flask-based web application (www/app.py) and its static assets (www/static/d3.v3.min.js) have been removed. This eliminates the legacy UI components, including the DAG tree/graph views, log viewer, and code display features that were previously served by the Flask app.
www · high confidence
Removal of legacy example DAGs and tutorial notebook
The \dags/examples\ directory has been cleared of all sample DAG definitions (\example1.py\ through \example3.py\, \hourly.py\, \test.py\, \test\_signal.py\) and the \Flux Tutorial\ Jupyter notebook. These files, which previously demonstrated basic task execution, dependency management, and sensor usage under the old 'Flux' project name, are no longer included in the distribution.
dags · high confidence
Security
Secure password comparison in Simple Auth Manager login
The Simple Auth Manager's login service now uses \hmac.compare\_digest\ for constant-time password comparison during authentication. This change mitigates timing side-channel attacks (CWE-208) by ensuring that password verification takes the same amount of time regardless of where a mismatch occurs, improving security for users relying on the simple authentication backend.
_airflow-core/src/airflow/api\fastapi/auth/managers/simple/services · high confidence
Architecture
Assets module relocated to airflow-core package
The asset management code, including the core AssetManager and related models, has been moved into the new airflow-core package. This structural change consolidates the asset logic within the core distribution, ensuring that asset-related functionality is available without requiring separate package dependencies.
airflow-core/src/airflow/assets · high confidence
Extract shared module loading utilities to a standalone distribution
The module loading logic previously scattered across the codebase has been consolidated into a new shared distribution (\airflow\_shared.module\_loading\). This change introduces a centralized library for importing strings, resolving entry points with distribution metadata, and discovering DAG files. Key utilities now include \import\_string\ for dotted-path imports, \entry\_points\_with\_dist\ for retrieving entry points alongside their source distributions, and enhanced DAG file detection in \dag\_file.py\ that supports checking both filesystem paths and in-memory \DagDefinition\ objects (such as those from ZIP archives) without requiring temporary file materialization.
_shared/module\loading · high confidence
Introduce airflow-core package with build and pre-commit tooling
The airflow-core package is established, containing the core Airflow components (scheduler, API server, DAG file processor, triggerer). This change adds the package's build infrastructure, including a custom hatch build script that compiles UI assets and generates git version stamps, a comprehensive pre-commit configuration using prek to enforce import, linting, and schema checks, and standard license and notice files.
airflow-core · high confidence
Introduction of shared library symlinks in airflow-core
The airflow-core package now includes a new \_shared directory containing symbolic links to various shared libraries (such as configuration, dagnode, listeners, logging, module\_loading, observability, plugins\_manager, providers\_discovery, secrets\_backend, secrets\_masker, serialization, state, template\_rendering, and timezones). This structural change allows airflow-core to vendor-in these shared components, enabling different packages to potentially use different versions of the same shared library while avoiding code duplication.
_airflow-core/src/airflow/\shared · high confidence
Models reorganized into airflow-core with lazy loading and SDK migration
The core database models have been moved into the new airflow-core package and are now exposed via a centralized \_\init\\_.py that uses lazy loading to import classes from their specific module files (such as backfill, dag\_version, dagbundle, and asset\_state\_store). This change migrates key components like DAG, BaseOperator, and XCom to the Task SDK, while introducing new models for backfill management, DAG versioning, and asset state tracking to support partitioned scheduling and improved metadata persistence.
airflow-core/src/airflow/models · high confidence
Move Airflow Config Parser to shared library
The configuration parsing logic has been extracted from the core Airflow distribution into a new shared library (shared/configuration). This change makes the base configuration parser, including its exception handling and core parsing mechanics, available for reuse across other Airflow distributions and components, decoupling the parsing implementation from the main core package.
shared/configuration · high confidence
OpenAPI specification files moved to airflow-core
The generated OpenAPI specification files (v2-rest-api-generated.yaml and \_private\ui.yaml) and the supporting \\init\\_.py and exceptions.py modules have been relocated from their previous location into the airflow-core package under airflow-core/src/airflow/api\_fastapi/core\_api/openapi. This change consolidates the API schema artifacts within the core package, ensuring they are distributed with the core installation and simplifying the build and deployment process for the REST API documentation.
_airflow-core/src/airflow/api\_fastapi/core\api/openapi · high confidence
Plugins manager moved to a shared library
The plugins manager implementation has been relocated to the shared library (shared/plugins\_manager), making the core plugin loading and registration logic available as a reusable component. This change consolidates the plugin management code, allowing other parts of the system to import and utilize the same plugin discovery and integration mechanisms (such as loading macros, listeners, and UI views) without duplicating the logic.
_shared/plugins\manager · high confidence
Refactor API parameter module into a structured package
The \airflow.api\_fastapi.common.parameters\ module has been split into a package with dedicated submodules (asset, base, dag, dag\_run, filter, job, misc, range, search, sort, task\instance, xcom) and a central \\\init\\_.py\ for backward-compatible re-exports. This reorganization improves maintainability and clarity of the query parameter helpers used across the FastAPI endpoints without changing their external behavior.
_airflow-core/src/airflow/api\fastapi/common/parameters · high confidence
Refactored DAG serialization into a modular definitions package
The serialization logic for DAGs, operators, and parameters has been reorganized from the previous monolithic structure into a new \airflow.serialization.definitions\ package. This change introduces dedicated modules for \SerializedDAG\, \SerializedBaseOperator\, \SerializedMappedOperator\, \SerializedTaskGroup\, and \SerializedParamsDict\, alongside supporting utilities like \DAGNode\ and \ArgNotSet\. For users, this represents an internal architectural shift to decouple serialization from the core SDK and improve modularity, ensuring that serialized objects (such as those stored in the database or passed between scheduler and webserver) are handled by these new, specific classes rather than the previous generic serialization objects.
airflow-core/src/airflow/serialization/definitions · high confidence
Relocates Airflow database migration infrastructure to airflow-core
The database migration files (Alembic configuration, environment setup, type definitions, and utility helpers) have been moved into the airflow-core package. This change centralizes the migration logic within the core distribution, ensuring that the migration environment and its dialect-specific handling (such as SQLite foreign key management and MySQL/PostgreSQL guard procedures) are consistently available as part of the main Airflow package rather than being scattered or external.
airflow-core/src/airflow/migrations · high confidence
Task instance dependency checks moved to airflow-core
The task instance (TI) dependency logic has been relocated into the \airflow-core\ package, with individual dependency classes (such as \DagTISlotsAvailableDep\, \MappedTaskUpstreamDep\, and \NotPreviouslySkippedDep\) now residing in \airflow-core/src/airflow/ti\_deps/deps\. This change consolidates the scheduling dependency checks within the core runtime, ensuring that the logic for validating task states, mapped task expansions, and pool availability is directly available to the scheduler without external package dependencies.
_airflow-core/src/airflow/ti\deps/deps · high confidence
Behavioural changes
1704 commits (222 fixes) modifying scripts
A change to existing behaviour in scripts — 1704 commits (222 fixs), 489 files: “Fix ts-compile-lint-simple-auth-manager-ui prek hook (\#64310)”; “Fix version detection for airflow-ctl and task-sdk in docs script (\#63917)”; “Remove openlineage exclusion (\#33491)”; and 1701 more (refs \#64310, \#63917, \#33491, \#11846, \#14915, …).
scripts · medium confidence · unverified
1772 commits (283 fixes) modifying dev/breeze
A change to existing behaviour in dev/breeze — 1772 commits (283 fixs), 129 files: “Bump hatch version to 1.15.0 (\#56652)”; “\[main\] Upgrade important CI environment (\#60475)”; “Better diagnostics for ARM for MySQL and MSSQL (\#24185)”; and 1769 more (refs \#56652, \#60475, \#24185, \#31601, \#23100, …).
dev/breeze · medium confidence · unverified
2 commits (0 fixes) modifying airflow-core/src/airflow/ui/src/components/PluginActions
A change to existing behaviour in airflow-core/src/airflow/ui/src/components/PluginActions — 2 commits, 11 files: “Tidy the ESLint config before the oxlint move (\#76477)”; “Let plugins add their own actions to Dag, run and task instance rows (\#75229)” (refs \#76477, \#75229).
airflow-core/src/airflow/ui/src/components/PluginActions · medium confidence · unverified
2 commits (0 fixes) modifying kubernetes-tests/lang\_sdk/ts\_example
A change to existing behaviour in kubernetes-tests/lang\_sdk/ts\_example — 2 commits, 1 file: “Cover native TypeScript and Java Dags, including control flow, in the e2e suites (\#73847)”; “Rename TypeScript SDK npm package to @apache-airflow/ts-sdk (\#75959)” (refs \#73847, \#75959).
_kubernetes-tests/lang\_sdk/ts\example · medium confidence · unverified
2 commits (1 fix) modifying airflow-core
A change to existing behaviour in airflow-core — 2 commits (1 fix), 3 files: “Fix failing \_\doc\\_ usage in case of PYTHONOPTIMIZE=2 (\#77013)”; “Show the same Dag in each language SDK in tabs (\#77002)” (refs \#77013, \#77002). Also in this area: Added unit tests for the Execution API head version.
_airflow-core/tests/unit/api\_fastapi/execution\api/versions · medium confidence · unverified
2036 commits (256 fixes) modifying dev
A change to existing behaviour in dev — 2036 commits (256 fixs), 550 files: “Add common.compat provider (\#40374)”; “\[DOCS\] fix link of colima installation guide (\#60625)”; “Group Dependabot security updates and keep v3-3-test covered (\#70556)”; and 2033 more (refs \#40374, \#60625, \#70556, \#66040, \#49031, …).
dev · medium confidence · unverified
2972 commits (534 fixes) modifying apache-airflow
A change to existing behaviour in apache-airflow — 2972 commits (534 fixs), 271 files: “Fix finding assets in serialized mapped operator (\#49210)”; “Remove warning for \BaseOperator.executor\ because its false (\#53496)”; “Remove unused \SimpleTaskInstance\ (\#52176)”; and 2969 more (refs \#49210, \#53496, \#52176, \#45294, \#48459, …).
apache-airflow · medium confidence · unverified
3 commits (0 fixes) modifying github.com/apache/airflow/go-sdk
A change to existing behaviour in github.com/apache/airflow/go-sdk — 3 commits, 1 file: “Decode Go SDK date-times from the supervisor in UTC (\#75737)”; “Go SDK: generate DagSpec and TaskSpec from the serialization schema (\#73936)”; “Generate data models from supervisor schema for Go-SDK (\#68629)” (refs \#75737, \#73936, \#68629).
github.com/apache/airflow/go-sdk · medium confidence · unverified
4 commits (0 fixes) modifying airflow-core/src/airflow/dag\_processing/bundles
A change to existing behaviour in airflow-core/src/airflow/dag\_processing/bundles — 4 commits, 3 files: “Move \GitDagBundle\ to providers (\#47636)”; “Move airflow sources to airflow-core package (\#47798)”; “Update description of provider.yaml dependencies (\#50231)”; and 1 more (refs \#47636, \#47798, \#50231, \#74789).
_airflow-core/src/airflow/dag\processing/bundles · medium confidence · unverified
4018 commits (858 fixes) modifying providers
A change to existing behaviour in providers — 4018 commits (858 fixs), 5879 files: “Deprecating email, email\_on\_retry, email\_on\_failure in BaseOperator (\#47146)”; “Add bounded retry cleanup for Redshift cluster deletion after post-creation failure. (\#63074)”; “Nest the \common.ai\ docs sidebar and lead with features and providers (\#73548)”; and 4015 more (refs \#47146, \#63074, \#73548, \#72090, \#70131, …).
providers · medium confidence · unverified
4230 commits (379 fixes) modifying (repo-wide)
A change to existing behaviour in (repo-wide) — 4230 commits (379 fixs), 45 files: “Add common.compat provider (\#40374)”; “Revert "Disable branch protection for old, inactive releases temporarily (\#45592)" (\#45594)”; “Add Phani and Pankaj as collaborators (\#31079)”; and 4218 more (refs \#40374, \#45592, \#45594, \#31079, \#8994, …).
(repo-wide) · low confidence · unverified
5 commits (0 fixes) modifying airflow-core/src/airflow/dag\_processing
A change to existing behaviour in airflow-core/src/airflow/dag\_processing — 5 commits, 6 files: “Move airflow sources to airflow-core package (\#47798)”; “Add HTTP publication to the Dag processor manager (\#74793)”; “Parse native Lang-SDK Dags in the Dag processor with their runtime (\#74035)”; and 2 more (refs \#47798, \#74793, \#74035, \#74043, \#74791).
_airflow-core/src/airflow/dag\processing · medium confidence · unverified
6 commits (0 fixes) modifying airflow-core/src/airflow/ui/src/components/Breadcrumb
A change to existing behaviour in airflow-core/src/airflow/ui/src/components/Breadcrumb — 6 commits, 5 files: “Add Map Index search to dag breadcrumb (\#74763)”; “Upgrade Task Loop UX (\#74671)”; “UI: Visual overhaul of Dag details layout for easier consumption (\#71957)”; and 3 more (refs \#74763, \#74671, \#71957, \#72349, \#74471, …).
airflow-core/src/airflow/ui/src/components/Breadcrumb · medium confidence · unverified
6 commits (1 fix) modifying airflow-core/src/airflow/ui/src/pages/DagBundles
A change to existing behaviour in airflow-core/src/airflow/ui/src/pages/DagBundles — 6 commits (1 fix), 3 files: “Upgrade UI major dependencies: msw, vitest, react-table and mermaid (\#74369)”; “Add a Dag bundle detail page listing the files in the bundle (\#73009)”; “Stop UI unit tests from leaking requests to the network (\#75084)”; and 3 more (refs \#74369, \#73009, \#75084, \#74426, \#74663, …).
airflow-core/src/airflow/ui/src/pages/DagBundles · medium confidence · unverified
6 commits (1 fix) modifying airflow-e2e-tests/java-test-bundle
A change to existing behaviour in airflow-e2e-tests/java-test-bundle — 6 commits (1 fix), 2 files: “Java SDK: Clearer error when a task class cannot be instantiated (\#69827)”; “Java SDK: Add setVariable and deleteVariable to the task Client (\#72676)”; “Revert "Make Java SDK context signal-aware (\#74690)" (\#75421)”; and 3 more (refs \#69827, \#72676, \#74690, \#75421, \#75920, …).
airflow-e2e-tests/java-test-bundle · medium confidence · unverified
7 commits (1 fix) modifying airflow-core/src/airflow/ui/src/pages/DagBundle
A change to existing behaviour in airflow-core/src/airflow/ui/src/pages/DagBundle — 7 commits (1 fix), 7 files: “Upgrade UI major dependencies: msw, vitest, react-table and mermaid (\#74369)”; “Add a Dag bundle detail page listing the files in the bundle (\#73009)”; “Give Dag bundles their own read permission (\#76329)”; and 4 more (refs \#74369, \#73009, \#76329, \#76462, \#73713, …).
airflow-core/src/airflow/ui/src/pages/DagBundle · medium confidence · unverified
8 commits (2 fixes) modifying providers/common/ai/src/airflow/providers/common/ai/plugins/www
A change to existing behaviour in providers/common/ai/src/airflow/providers/common/ai/plugins/www — 8 commits (2 fixs), 35 files: “AIP-99 Add HITL Review system for AgenticOperator (\#63081)”; “Fix skill call counts and source links in the AI Model tab (\#76541)”; “Show which skills an agent was offered and used in the AI Model tab (\#76309)”; and 5 more (refs \#63081, \#76541, \#76309, \#74334, \#76747, …).
providers/common/ai/src/airflow/providers/common/ai/plugins/www · medium confidence · unverified
Agent skills relocated to canonical home with .claude symlinks
The agent skills are now canonically stored in the .agents/skills directory. To maintain compatibility, the .claude/skills directory now contains symbolic links pointing to these canonical skill definitions (such as aip-user-stories, upgrade-fab-provider, and others), ensuring that the agent configuration continues to locate and load the skills correctly from their new location.
.claude · high confidence
Airbyte provider v6.2.0 requires Airflow 2.11+ and adds configurable timeouts and proxy support
The Airbyte provider has been updated to version 6.2.0, which now enforces a minimum Apache Airflow version of 2.11.0. This release introduces several behavioral improvements: the AirbyteHook now supports configurable request timeouts and HTTP proxies via connection extra fields, and OAuth credentials (Client ID/Secret) are optional to support Airbyte OSS deployments without authentication. Additionally, the AirbyteTriggerSyncOperator and AirbyteJobSensor have improved deferrable execution timeout handling, ensuring that jobs are properly cancelled when the task-level execution timeout is reached.
providers/airbyte · high confidence
Airflow CLI restructured with new core modules and development features
The CLI implementation in airflow-core has been reorganized into dedicated modules (cli\_config, cli\_parser, hot\_reload, simple\_table, utils) to support a flatter command structure and improved developer experience. This change introduces hot-reload support for development mode via the --dev flag, allowing CLI processes to automatically restart on source file changes. It also adds utilities for masking sensitive values in CLI output, warnings for incomplete connection/variable listings when external secrets backends are used, and redirects log output to stderr to keep structured command output (JSON/YAML) parseable. Additionally, CLI commands are now marked for migration to airflowctl without emitting user-facing deprecation warnings, and the parser now prevents subcommands from being silently dropped.
airflow-core/src/airflow/cli · high confidence
Airflow UI restructured as a standalone Vite/React application with new tooling and testing infrastructure
The Airflow UI has been reorganized into a dedicated \airflow-core/src/airflow/ui\ directory, adopting a modern Vite-based React and TypeScript architecture. This change introduces a new development environment with strict TypeScript configuration, ESLint rules, and Prettier formatting, alongside the integration of the React Compiler to handle memoization automatically. For testing, the UI now includes a comprehensive Playwright E2E framework and Vitest unit testing setup with MSW for API mocking, ensuring robust validation of user interactions. Additionally, the build process is optimized for performance and compatibility, including specific handling for static assets and graph layout workers.
airflow-core/src/airflow/ui · high confidence
Airflow core package structure reorganization
The Airflow codebase has been restructured to move core sources into the \airflow-core\ package. This change introduces a new \airflow.\_vendor\ directory for managing vendored third-party libraries, adds example DAG assets including SQL templates and helper scripts, and updates the UI asset library with new Chakra UI icons for the Airflow pin, DAGs, and tasks.
(repo-wide) · high confidence
Alibaba provider upgraded to OSS SDK v2 and bumped minimum Airflow version to 2.11.0
The Alibaba provider now requires Apache Airflow 2.11.0 or later, as enforced by a runtime check in the package's \_\init\\_.py. Additionally, the OSS integration has been migrated from the legacy oss2 library to the new alibabacloud-oss-v2 SDK, which updates the underlying client used by the OSSHook and its associated operators and sensors.
providers/alibaba · high confidence
Apache Beam provider requires Airflow 2.11.0+ and adopts Task SDK compatibility
The Apache Beam provider now enforces a minimum Apache Airflow version of 2.11.0, raising the previous requirement of 2.10. Internally, the provider has migrated from the legacy \BaseHook\ to the Task SDK's \BaseOperator\ and \BaseHook\ implementations via \airflow.providers.common.compat.sdk\, ensuring compatibility with modern Airflow architectures. This change also introduces version-specific compatibility logic (e.g., \AIRFLOW\_V\_3\_1\_PLUS\) and updates the provider's metadata and initialization files to reflect these structural shifts.
providers/apache/beam · high confidence
Apache Cassandra provider updated for Airflow 2.11+ and Task SDK compatibility
The Apache Cassandra provider now requires Apache Airflow 2.11.0 or later, enforcing this via a runtime check in the package metadata. Internally, the CassandraHook and its sensors (CassandraRecordSensor, CassandraTableSensor) have been migrated to inherit from the Task SDK's BaseHook and BaseSensorOperator classes (imported via airflow.providers.common.compat.sdk), replacing the previous Airflow-specific base classes. This change aligns the provider with the new Task SDK architecture while maintaining the same user-facing API for connections, hooks, and sensors.
providers/apache/cassandra · high confidence
Apache Druid provider upgraded to require Airflow 2.11+ and migrated to Task SDK
The Apache Druid provider now requires Apache Airflow 2.11.0 or later, enforcing this via a runtime check in the package metadata. Under the hood, the provider has been migrated to the new Airflow 3.0-compatible structure, replacing the legacy BaseHook and BaseOperator implementations with their Task SDK equivalents from airflow.providers.common.compat.sdk. This change modernizes the DruidHook and DruidOperator to align with the new execution model while maintaining the same user-facing API for submitting ingestion jobs and transferring data from Hive.
providers/apache/druid · high confidence
Apache Hive provider v9.7.1 requires Airflow 2.11.0+ and adopts Task SDK base classes
The Apache Hive provider has been updated to version 9.7.1, which enforces a minimum Apache Airflow version of 2.11.0. To align with the modern Airflow architecture, the provider's core components—including operators, sensors, and hooks—now inherit from the Task SDK's \BaseOperator\, \BaseSensorOperator\, and \BaseHook\ instead of the legacy Airflow base classes. This migration ensures compatibility with the latest Airflow runtime and SDK features.
providers/apache/hive, providers/ftp · high confidence
Apache Iceberg provider now requires Airflow 2.11.0 and uses Task SDK hooks
The apache.iceberg provider has been updated to require Apache Airflow 2.11.0 or later, enforcing this via a runtime check in the package initialization. The IcebergHook now inherits from the Task SDK's BaseHook (via common.compat) instead of the legacy implementation, and the provider includes a new IcebergTableSnapshotTrigger for event-driven scheduling based on table snapshot changes.
providers/apache/iceberg · high confidence
Apache Impala provider now requires Airflow 2.11.0+
The Apache Impala provider has been updated to enforce a minimum Apache Airflow version of 2.11.0. If you are running an older version of Airflow, the provider will now raise a RuntimeError at import time, preventing compatibility issues. This change accompanies a structural migration of the provider to a new package layout and the adoption of the common compatibility SDK for version checks.
(repo-wide) · high confidence
Apache Kafka provider now requires Airflow 2.11.0 and adds MSK IAM authentication support
The Apache Kafka provider has been updated to require Apache Airflow 2.11.0 or later, enforcing this via a runtime check in the package's \\_\init\\_.py\. Additionally, the provider now supports Amazon MSK IAM authentication by automatically injecting an OAUTHBEARER token callback when connecting to MSK bootstrap servers, and introduces a security-focused \callback\_allowlist\ configuration option to control which callable callbacks can be resolved from connection extra dictionaries.
providers/apache/kafka · high confidence
Apache Kylin provider updated for Airflow 2.11+ and modernized architecture
The Apache Kylin provider now requires Apache Airflow 2.11.0 or later, enforcing this via a runtime check in the package metadata. The provider has been migrated to the new provider structure, introducing a \get\_provider\info.py\ file for metadata and namespace \\\init\\_.py\ files for proper package resolution. Internally, the \KylinHook\ and \KylinCubeOperator\ now inherit from \BaseHook\ and \BaseOperator\ provided by \airflow.providers.common.compat.sdk\, ensuring compatibility with the updated Airflow SDK. A new \version\_compat.py\ module is included to support version-specific logic, such as detecting Airflow 3.0+.
providers/apache/kylin · high confidence
Apache Livy provider now requires Airflow 2.11+ and supports durable, resumable batch jobs
The Apache Livy provider has been updated to require Apache Airflow 2.11.0 or later, as enforced by a runtime check in the package's \\_\init\\_.py\. This release introduces support for durable, resumable Spark batch jobs via the \durable\ parameter on \LivyOperator\; when enabled on Airflow 3.3+, the operator persists the Livy batch ID before polling, allowing a crashed worker to reconnect to the running batch on retry instead of submitting a duplicate job. On earlier Airflow versions, the \durable\ flag is a no-op and triggers a warning. The provider also migrates its core components to the Task SDK (\BaseOperator\, \BaseSensorOperator\) and integrates OpenLineage configuration injection for Spark jobs.
providers/apache/livy · high confidence
Apache Pig provider adopts Task SDK and raises minimum Airflow version to 2.11
The Apache Pig provider has been migrated to the new provider structure, replacing its internal \BaseOperator\ and \BaseHook\ implementations with the corresponding classes from the Task SDK (\airflow.providers.common.compat.sdk\). This change enforces a minimum Apache Airflow version of 2.11.0; attempting to install this provider version (4.9.1) on older Airflow releases will now raise a runtime error. Additionally, the provider now includes a \get\_provider\_info.py\ file to expose metadata for operators, hooks, and the \pig\_cli\ connection type.
providers/apache/pig · high confidence
Apache Pinot provider requires Airflow 2.11.0+ and adopts new provider structure
The Apache Pinot provider now enforces a minimum Apache Airflow version of 2.11.0, raising the previous requirement and ensuring compatibility with the latest platform features. This update also migrates the provider to the new package structure, introducing namespace package initialization files and a standardized \get\_provider\_info.py\ metadata file. Additionally, the Pinot hooks have been updated to inherit from the Task SDK's \BaseHook\ and now support username and password authentication for the Pinot Admin connection, allowing users to pass credentials to the underlying \pinot-admin.sh\ commands.
providers/apache/flink, providers/apache/pinot · high confidence
Asset event cards now distinguish triggering runs from included runs
The Asset Events UI now separates the list of runs associated with an event into two distinct groups: those that were triggered by the event and those that merely included it. This is implemented via the new TriggeredRuns component, which uses the backend's \triggering\ flag to label runs as 'triggered' or 'included', and the AssetEvent component now displays this grouped information alongside the event timestamp and source.
airflow-core/src/airflow/ui/src/components/Assets · high confidence
Atlassian Jira provider now requires Airflow 2.11.0 and adds async capabilities
The Atlassian Jira provider has been updated to require Apache Airflow 2.11.0 or later, enforcing this constraint at import time. This release introduces an asynchronous Jira hook (\JiraAsyncHook\) and a corresponding async notification mechanism (\JiraNotifier.async\_notify\), enabling non-blocking Jira interactions. Additionally, the provider's core components (operators, sensors, hooks) have been migrated to use the Task SDK base classes (\BaseOperator\, \BaseSensorOperator\, \BaseHook\) for improved compatibility and performance.
providers/atlassian/jira · high confidence
Backward compatibility shim for BaseNotifier
The airflow-core package now includes a compatibility shim in the airflow.notifications module that redirects the legacy BaseNotifier class to its new location in airflow.sdk.bases.notifier. This ensures that existing code importing from the old path continues to function without breaking, while users are encouraged to update their imports to the new SDK location.
airflow-core/src/airflow/notifications · high confidence
Backward-compatible team-scoped secret lookups in shared secrets backend
The shared secrets backend now supports the new \team\_name\ parameter for connection and variable lookups while maintaining compatibility with older custom or bundled backends. The \BaseSecretsBackend\ class in \shared/secrets\_backend\ introduces introspection logic that checks whether a backend's override methods accept the \team\_name\ argument; if they do, the argument is forwarded, otherwise it is omitted. This ensures that existing backends written for previous Airflow versions continue to function without modification, while new 3.2+ backends can leverage team-scoped secret resolution.
_shared/secrets\backend · high confidence
BaseHook and deprecated hooks relocated to airflow-core
The \BaseHook\ implementation has been moved to the task SDK (\airflow.sdk.bases.hook\), while the \airflow-core\ package now provides a compatibility layer that exposes the legacy \BaseHook\ and other hooks (such as \FSHook\, \PackageIndexHook\, and \SubprocessHook\) via deprecated aliases. Users relying on the old import paths will continue to work but will receive deprecation warnings directing them to the new locations or provider-specific hooks, ensuring a smooth transition as hook logic is consolidated into the SDK and provider distributions.
airflow-core/src/airflow/hooks · high confidence
CLI commands migrated to airflowctl and restructured
The CLI commands in the airflow-core package have been restructured to mark existing commands as deprecated in favor of the new airflowctl tool. This includes commands for assets, backfills, configurations, connections, DAGs, and database operations. The changes introduce deprecation warnings that guide users toward the corresponding airflowctl commands, while maintaining backward compatibility for existing workflows. Additionally, the API server command now supports both uvicorn and gunicorn server types, with gunicorn providing rolling worker restarts for better memory management.
airflow-core/src/airflow/cli/commands · high confidence
Celery provider restructured for Airflow 3.0+ with multi-team and workload support
The Celery provider has been migrated to the new provider code structure, raising the minimum supported Airflow version to 2.11.0 and introducing native support for Airflow 3.0+ workloads and multi-team configurations. This update brings team-specific Celery app isolation, allowing distinct broker connections per team, and aligns the executor with the Task SDK for task execution. The provider now includes a dedicated CLI for worker and queue management, supports stale DAG bundle cleanup, and enforces explicit PostgreSQL driver selection (psycopg2 or psycopg) for result backends. Legacy hybrid executors like CeleryKubernetesExecutor are deprecated for Airflow 3.0+ in favor of concurrent executor usage.
providers/celery · high confidence
Centralize UI configuration and filter definitions into shared constants
The Airflow UI now consolidates scattered configuration values into a dedicated \src/constants\ directory, providing a single source of truth for user-facing settings and interface behavior. This change introduces centralized definitions for URL search parameters (\searchParams.ts\), localStorage keys for user preferences like timezone and log display (\localStorage.ts\), and filter configurations for DAGs, runs, and tasks (\filterConfigs.ts\, \stateOptions.ts\). It also standardizes UI elements such as DAG view types (\dagView.ts\), tab routing (\tab.ts\), and sorting options (\sortParams.ts\). Additionally, legacy localStorage keys for tag filters and dependency toggles are automatically cleaned up to prevent clutter, ensuring a consistent and maintainable foundation for UI features.
airflow-core/src/airflow/ui/src/constants · high confidence
Centralized database query helpers for the Airflow REST API
This change introduces a new \airflow.api\_fastapi.common.db\ package that consolidates database access logic for the FastAPI-based REST API. It provides shared utilities for cursor-paginated listings with bounded row counts, async session handling, and optimized eager-loading strategies for key resources. Specifically, it adds helpers to efficiently fetch Assets with their latest events, load DagRuns with their distinct version IDs without traversing all attempts, and query Dags with their latest runs while respecting user access filters. It also includes a centralized method to eager-load team information for Dags and Task Instances, ensuring consistent serialization of owning teams across the API.
_airflow-core/src/airflow/api\fastapi/common/db · high confidence
Cloudant provider now requires Apache Airflow 2.11.0+
The Cloudant provider has been updated to enforce a minimum Apache Airflow version of 2.11.0, raising the previous requirement. This change is part of a broader migration to the common.compat compatibility layer, which updates the CloudantHook to inherit from the BaseHook implementation in the task SDK and standardizes exception handling. Additionally, the provider's connection UI metadata has been migrated to a YAML-based configuration in get\_provider\_info, simplifying how connection fields like Account and Username are displayed in the Airflow UI.
(repo-wide) · high confidence
Common IO provider restructured for Airflow 2.11+ with new object storage backends
The \apache-airflow-providers-common-io\ package has been restructured and now requires Apache Airflow 2.11.0 or later. This update introduces a new \StateStoreObjectStorageBackend\ for persisting task and asset state to object storage, configurable via \state\_store\_objectstorage\_path\, \state\_store\_objectstorage\_threshold\, and \state\_store\_objectstorage\_compression\. The existing \XComObjectStorageBackend\ is also updated to use the new \airflow.sdk\ APIs and \ObjectStoragePath\ for Airflow 3.0+, while maintaining compatibility with earlier versions. Additionally, the \FileTransferOperator\ now leverages the Task SDK's \BaseOperator\ and \ObjectStoragePath\ for improved path handling and lineage reporting.
providers/common/io · high confidence
DAG serialization code moved to airflow-core with deprecation shim
The serialization logic (encoders, decoders, helpers, schema, and stub\_arg\_bindings) has been relocated into the airflow-core package. To maintain backward compatibility, the old import path now exposes a deprecation shim that redirects users to the new airflow.sdk.serde module.
airflow-core/src/airflow/serialization · high confidence
Dashboard Health section now displays individual component instances and supports multi-team environments
The Health section on the Dashboard has been rewritten to provide a more detailed view of Airflow components. It now lists every running instance of the scheduler, triggerer, and DAG processor, showing their hostnames and latest heartbeats. The status display has been updated to prefer the API's \detailed\_status\ (which includes a 'degraded' state for partial coverage) over the legacy \status\. Additionally, when the \multi\_team\ configuration is enabled, the instance lists now display the teams associated with each triggerer instance and the bundles associated with each DAG processor instance. The section also features auto-refresh capabilities to keep this information current.
airflow-core/src/airflow/ui/src/pages/Dashboard/Health · high confidence
Database schema migration chain for Airflow 2.6.2 through 2.10.0
The migration files in this location define the database schema evolution from Airflow v2.6.2 up to v2.10.0. This includes the initial squashed migration establishing the base schema, followed by incremental changes such as adding the \clear\_number\ field to \dag\_run\, introducing \dataset\_expression\ and \max\_consecutive\_failed\_dag\_runs\ to the \dag\ model, adding display names for DAGs and tasks, updating trigger kwargs encryption, and adding indexes on \dag\_id\ columns in referencing tables to improve query performance.
airflow-core/src/airflow/migrations/versions · high confidence
Databricks provider version 7.22.0 with Airflow 2.11+ requirement
The Databricks provider has been updated to version 7.22.0, which now requires Apache Airflow 2.11.0 or later. This release includes a comprehensive refactor of error handling with new specific exception classes (such as DatabricksApiError and DatabricksSqlExecutionError), support for durable execution in run operators, and improved handling of paginated run data to prevent task loss. It also adds support for user-assigned managed identity authentication on Azure, durable retries for blocked runs, and deferrable modes for SQL warehouse operators.
providers/databricks · high confidence
Deprecated operator imports moved to airflow-core with backcompat shims
The \airflow.operators\ module in \airflow-core\ now serves as a compatibility layer that redirects deprecated imports to their new locations. Operators such as \PythonOperator\, \BashOperator\, and \EmailOperator\ are now imported from \airflow.providers.standard\ or \airflow.providers.smtp\, while utility functions like \get\_current\_context\ and mixins like \BranchMixIn\ are redirected to the \airflow.sdk\. Existing DAGs using these legacy import paths will continue to work but will receive deprecation warnings, guiding users to update their imports to the new provider-based or SDK-based locations.
airflow-core/src/airflow/operators · high confidence
Deprecated serialization module redirects to SDK
The \airflow.serialization.serializers\ module has been deprecated and now acts as a shim that redirects imports to \airflow.sdk.serde.serializers\. Users importing from the old location will receive a deprecation warning, signaling that they should update their code to use the new SDK path for serialization functionality.
airflow-core/src/airflow/serialization/serializers · high confidence
Deprecation of airflow.macros in favor of Task SDK
The \airflow.macros\ module is now deprecated and redirects users to \airflow.sdk.execution\_time.macros\. Existing code importing from the old location will continue to function but should migrate to the Task SDK's execution-time macros to ensure compatibility with future versions.
airflow-core/src/airflow/macros · high confidence
Deprecation of legacy airflow.utils modules and relocation of I/O utilities
The \airflow.utils\ package now serves as a deprecation layer, redirecting imports for modules such as \context\, \dag\_cycle\_tester\, \setup\_teardown\, \xcom\, \task\_group\, \timezone\, \decorators\, \timeout\, \trigger\_rule\, \operator\_resources\, \weight\_rule\, and \entry\_points\ to their new locations in the Task SDK or other core packages. Additionally, the \airflow.io\ module has been introduced to provide backward-compatible shims for I/O utilities (like \get\_fs\, \has\_fs\, and \Properties\), redirecting them to the Task SDK's \airflow.sdk.io\ implementation.
airflow-core/src/airflow/utils · high confidence
Dynamic theme configuration via Chakra UI provider
The UI now supports runtime theme customization by introducing a new ChakraCustomProvider component. This component fetches the active theme configuration from the backend and dynamically generates a Chakra UI theme object, which is then passed to the ChakraProvider. Additionally, the generated theme system is exposed globally on the window object to ensure that dynamically imported React plugins can inherit and use the same core theme settings.
airflow-core/src/airflow/ui/src/context · high confidence
E2E test bundle now loads dynamic DAGs from YAML
The Java native bundle used in end-to-end tests now supports dynamically loading DAG definitions from a \dags.yaml\ file located next to the JAR. A new \DynamicDags\ class parses this YAML at runtime to register additional DAGs, allowing the test suite to cover scenarios where DAGs are generated via YAML rather than hardcoded in Java classes. This change enables the e2e tests to validate behavior for YAML-generated DAGs without requiring a rebuild of the bundle. Also in this area: Java SDK annotation namespace renamed from Builder to Airflow; Added e2e test bundles for native Java and TypeScript DAGs.
airflow-e2e-tests/java-native-bundle · high confidence
Elasticsearch provider now requires Airflow 2.11.0+ and adds compatibility pinning for ES 8 servers
The Elasticsearch provider has been updated to require Apache Airflow 2.11.0 or later, enforcing this via a runtime check in the package initialization. Additionally, to resolve connectivity issues when using the Elasticsearch Python client 9.x with Elasticsearch 8.x servers, the provider now includes a new \\[elasticsearch\] es\_compat\_with\ configuration option. Setting this option (e.g., to "8") pins the HTTP content-negotiation level, preventing "media\_type\_header\_exception" errors and ensuring remote logging and SQL queries work correctly across mixed client/server major versions.
providers/elasticsearch · high confidence
Enhanced security and robustness in API audit logging
The API audit logging system now masks sensitive data in connection extra fields and variable values, including support for bulk request bodies, and attributes log entries to specific task attempts. It also prevents log injection by stripping CR/LF characters from user-supplied values and handles non-dictionary or invalid JSON payloads gracefully to avoid internal server errors.
_airflow-core/src/airflow/api\fastapi/logging · high confidence
Exasol provider restructured for Airflow 2.11+ with pyexasol 2.x and SQLAlchemy support
The Exasol provider has been reorganized into a new package structure and now requires Apache Airflow 2.11.0 or later. The underlying database driver has been upgraded to pyexasol 2.x, and the provider now includes explicit SQLAlchemy support, allowing users to construct SQLAlchemy URLs and URIs via the hook. The ExasolOperator has been updated to inherit from the common SQLExecuteQueryOperator, and the legacy get\_pandas\_df method is deprecated in favor of get\_df.
providers/exasol · high confidence
Execution API security and token management overhaul
The Execution API now enforces stricter token-based security with two distinct token scopes: 'execution' (default, short-lived) and 'workload' (restricted, long-lived). A new JWTReissueMiddleware automatically refreshes expiring execution tokens by returning a 'Refreshed-API-Token' header, preventing task failures due to token expiration while waiting in executor queues. Route-level access control is handled via ExecutionAPIRoute, which precomputes allowed token types to ensure workload tokens are only accepted on endpoints that explicitly opt in. Additionally, correlation-id support has been added for request tracing, and the API uses Cadwyn for versioning to maintain backward compatibility between workers and API servers.
_airflow-core/src/airflow/api\_fastapi/execution\api · high confidence
Execution API versioning and migration overhaul
The Execution API now uses a structured versioning system (via Cadwyn) to manage schema and endpoint changes, ensuring backward compatibility with older Task SDK clients. This change consolidates previously unreleased API versions into a defined timeline (2025-04-11 through 2026-10-30) and introduces specific migration logic for key updates: adding fields like \rendered\_map\_index\, \dag\_version\_id\, \triggering\_user\_name\, \team\_name\, and \partition\_date\; exposing new endpoints for DAG details, asset states, and connection tests; and adjusting data types (e.g., making \dag\_run.conf\ nullable, modifying \upstream\_map\_indexes\ handling). It also includes fixes for deferred task kwargs serialization and ensures that older clients receive correctly downgraded responses for these new fields and endpoints.
_airflow-core/src/airflow/api\_fastapi/execution\api/versions · high confidence
Executor subsystem moved to airflow-core with multi-team support
The executor implementation has been relocated from the provider packages into the airflow-core package, making LocalExecutor, CeleryExecutor, and KubernetesExecutor core components. This change introduces multi-team configuration support, allowing users to assign specific executors to named teams via the configuration file, with the ExecutorLoader handling team validation and alias resolution. The LocalExecutor has been updated to support this multi-team context, including process title prefixes that reflect the team name, and internal bookkeeping improvements to correctly track running tasks and prevent deadlocks.
airflow-core/src/airflow/executors · high confidence
Facebook provider now requires Airflow 2.11.0 and uses updated compatibility layer
The Facebook provider has been restructured to enforce a minimum Apache Airflow version of 2.11.0, raising the bar from the previous 2.10 requirement. To support this, the provider now imports \BaseHook\ and \AirflowException\ from the common SDK compatibility layer (\airflow.providers.common.compat.sdk\) instead of the legacy namespace, and includes a \version\_compat\ module to handle version-specific logic. This ensures the provider remains compatible with the newer Airflow core while maintaining backward compatibility for exception handling.
providers/facebook · high confidence
FastAPI Core API server initialization and security model
The Airflow API server has been restructured to use a new FastAPI-based core API located in \airflow/api\_fastapi/core\api\. This change introduces a new application entry point (\app.py\) that registers UI translation views, serves static assets, and explicitly returns 404 errors for legacy \/health\ and \/api/v1/\\ endpoints to prevent accidental exposure of old paths. The security layer (\security.py\) implements a robust authentication model using JWT tokens via Bearer headers or cookies, featuring a trusted middleware sentinel to prevent user injection attacks, and collects all presented credentials to ensure complete revocation during logout.
_airflow-core/src/airflow/api\_fastapi/core\api · high confidence
GitHub provider restructured for Airflow 3.0 with App authentication support
The GitHub provider has been migrated to a new package structure and updated to require Apache Airflow 2.11.0 or later, ensuring compatibility with the upcoming Airflow 3.0 release. The \GithubHook\ now supports GitHub App Installation Authentication via \private\_key\ or \key\_path\ connection extras, in addition to the existing token-based auth. Internally, the provider hooks, operators, and sensors now inherit from the Task SDK's \BaseHook\, \BaseOperator\, and \BaseSensorOperator\ respectively, and use the \common.compat\ module for version compatibility checks.
providers/github · high confidence
Global navigation sidebar is rebuilt with role-based menus and plugin support
The Airflow UI navigation has been completely rewritten as a fixed sidebar. It now features distinct, role-filtered menu buttons for Admin (Variables, Pools, Configs, etc.), Browse (Audit Log, Jobs, Deadlines), and Docs (with conditional REST API reference visibility). Plugin-provided views are integrated via a dedicated PluginMenus component that supports top-level toolbar placement and categorized submenus. The new NavButton component handles active-state highlighting for single or multiple routes, supports external links, and includes a matchPaths feature for nested route activation. Additional features include a language selector modal, a timezone selector, and a logout confirmation modal that respects the configured base URL.
airflow-core/src/airflow/ui/src/layouts/Nav · high confidence
Google provider restructured to new layout with version 22.7.0 and Airflow 2.11+ requirement
The Google provider has been reorganized into a new directory structure, introducing new package initialization files and a version file that sets the provider version to 22.7.0. This update enforces a minimum Apache Airflow version of 2.11.0, ensuring compatibility with the latest core features. Additionally, the provider now includes a vendored JSON merge patch utility and updated licensing information.
providers/google · high confidence
HTTP provider version 6.3.0 requires Apache Airflow 2.11.0+
The HTTP provider has been updated to version 6.3.0 and now enforces a minimum Apache Airflow version of 2.11.0. If you are running an older version of Airflow, the provider will raise a RuntimeError upon import. This change also introduces new exception classes (HttpErrorException, HttpMethodException, HttpSrvLookupException) and adds support for DNS SRV record lookups in HTTP connections.
providers/dbt/cloud, providers/http · high confidence
Helm chart source tree restructured and vendored
The Helm chart directory has been reorganized to include its own build infrastructure and documentation sources. New files include \.gitignore\ and \.helmignore\ to exclude build artifacts and test files from the packaged chart, a \.pre-commit-config.yaml\ for local development linting, and \dockerfiles/\ containing the Dockerfiles and build scripts for the bundled PgBouncer and PgBouncer-exporter images. The chart now ships with its \docs/\ source (RST) and \newsfragments/\ for release notes, and the \Chart.lock\ pins the PostgreSQL subchart to version 13.2.24.
chart · high confidence
Improved Python f-string syntax highlighting in the Dag Code editor
The Dag Code tab now correctly highlights Python f-strings, including multi-line triple-quoted strings and escaped braces ({{ and }}). This is achieved by applying a custom grammar patch to the Monaco editor that fixes upstream tokenization issues, ensuring that string content, interpolations, and literal braces are colored accurately. The change also registers TypeScript, Java, and Go grammars for the Dag Code tab and updates the Monaco editor configuration to use local modules and same-origin worker shims for better reliability.
airflow-core/src/airflow/ui/src/components/MonacoEditor · high confidence
Improved language detection and synchronized date formatting
The UI now correctly resolves browser language preferences, ensuring that region-specific variants (like en-GB or pt-BR) map to the supported base language (en, pt) without being incorrectly overridden by lower-priority languages, and that Chinese variants (zh-CN/zh-TW) are preserved. Additionally, date and duration formatting in the UI (e.g., "2 hours") now correctly uses the selected language's locale via dayjs, matching the i18next language setting.
airflow-core/src/airflow/ui/src/i18n · high confidence
Improved one-click re-triggering and paused DAG handling in the Trigger DAG modal
The Trigger DAG UI now allows users to re-trigger a DAG with a previous run's configuration in a single click via a new options caret on the trigger button, bypassing the form when no edits are needed. For paused DAGs, the modal now presents explicit options to unpause, drain (allowing unfinished runs to complete), or keep the DAG paused, and displays the count of unfinished runs for the first two options. The trigger button is also disabled when manual runs are denied, and the form now correctly handles empty configurations as having no config.
airflow-core/src/airflow/ui/src/components/TriggerDag · high confidence
Improved reliability for proxied deployments and permission errors
The UI now correctly handles being served under a path prefix (e.g., /airflow) by reading the HTML base tag to configure the API client, ensuring requests do not land on the wrong origin. It also prevents request spamming by blocking further polling to endpoints that previously returned 403 Forbidden, and provides clearer feedback by showing a toast notification for 403 errors on user actions.
airflow-core/src/airflow/ui/src · high confidence
Introduce Job Runner architecture and new task states
This change refactors the internal job execution model by introducing a Job Runner pattern (BaseJobRunner, DagProcessorJobRunner, SchedulerJobRunner) that separates the ORM Job instance from the execution logic, supporting both in-process and remote execution via an internal API. It also adds two new task instance states: DEFERRED, which now counts towards task-level concurrency limits (max\_active\_tis\_per\_dag) but not pool slots, and AWAITING\_INPUT for Human-in-the-loop scenarios, which counts towards concurrency but never reserves pool slots.
airflow-core/src/airflow/jobs · high confidence
Introduce Pydantic v2 datamodels for the FastAPI core endpoints
The REST API response and request schemas in the core API have been migrated to Pydantic v2. This change introduces new data models for assets, backfills, DAG bundles, DAG runs, plugins, and other core entities, replacing the previous serialization layer. For users, this means the API now enforces stricter validation on incoming requests and provides consistent, type-safe responses across all endpoints, including support for new fields like partition keys in backfills and asset references.
_airflow-core/src/airflow/api\_fastapi/core\api/datamodels · high confidence
Introduce public API service layer with bulk operations and sensitive data masking
The public API service layer in \airflow-core/src/airflow/api\_fastapi/core\_api/services/public\ has been restructured to centralize business logic for bulk operations and sensitive data handling. This change introduces a \BulkService\ base class and concrete implementations for Dags, Connections, Pools, and Task Instances, enabling bulk create, update, and delete actions with proper existence handling (fail, skip, or overwrite). It also implements strict masking for sensitive configuration values (including per-key secrets-backend kwargs) and ensures that sensitive fields in Connections and Pools are correctly merged or masked during updates, preventing accidental exposure or silent reset of unset fields.
_airflow-core/src/airflow/api\_fastapi/core\api/services/public · high confidence
Introduce structured workload schemas for executor communication
The executor workload definitions have been refactored to use explicit Pydantic-based schemas (ExecuteTask, ExecuteCallback, TestConnection, RunTrigger) located in the new workloads package. This change standardizes how tasks, callbacks, and connection tests are serialized and sent to workers, introducing dedicated DTOs like TaskInstanceDTO that include executor-specific fields such as pool\_slots and priority\_weight. It also establishes a unified type system (ExecutorWorkload, All) to strictly discriminate between workload types, ensuring that only valid workloads are dispatched to executors and that trigger-specific workloads are correctly separated from executor-bound workloads.
airflow-core/src/airflow/executors/workloads · high confidence
Introduction of the Callback Sink abstraction in airflow-core
The callback handling logic has been moved into the airflow-core package, introducing a new \BaseCallbackSink\ interface and a \DatabaseCallbackSink\ implementation. This change establishes a structured way to send callback requests (such as Dag Processor callbacks) by persisting them to the database via a new \DbCallbackRequest\ model, replacing the previous ad-hoc handling.
airflow-core/src/airflow/callbacks · high confidence
Jenkins provider requires Airflow 2.11+ and migrates to task SDK base classes
The Jenkins provider now enforces a minimum Apache Airflow version of 2.11.0, raising a runtime error if an older version is detected. Internally, the provider has migrated its core components to use the task SDK: the Jenkins hook now inherits from \BaseHook\ in \airflow.providers.common.compat.sdk\, while the \JenkinsJobTriggerOperator\ and \JenkinsBuildSensor\ inherit from \BaseOperator\ and \BaseSensorOperator\ respectively. This change updates the underlying implementation for connection handling and task execution without altering the public API or configuration options for users.
providers/jenkins · high confidence
Lineage module relocated to Airflow Core with deprecation shims
The lineage module has been moved back into the airflow-core package (from the task SDK), restoring its previous location. To maintain backward compatibility, the module now includes deprecation shims that redirect imports from airflow.lineage to airflow.sdk.lineage, ensuring existing code continues to function while signaling the intended migration path.
airflow-core/src/airflow/lineage · high confidence
Log server rewritten with FastAPI and JWT authentication
The serve\_logs utility has been refactored to use FastAPI instead of the previous implementation. This change introduces JWT-based authentication for log access, ensuring that only authorized requests can retrieve task logs via the /log endpoint. The server now uses uvicorn for ASGI handling, respects the new uvicorn\_logging\_level configuration, and simplifies IPv4/IPv6 binding logic. Additionally, HTTP access logs are disabled by default to prevent non-JSON noise when structured logging is enabled.
_airflow-core/src/airflow/utils/serve\logs · high confidence
Logging subsystem moved to airflow-core with structured log streaming and symlink fixes
The logging utilities have been relocated into the airflow-core package, introducing a structured log format (JSON) for task logs and enabling streaming log support in the FileTaskHandler. This change improves memory efficiency for large logs via the new LogStreamAccumulator, which spills to temporary files, and fixes issues with stale symlinks in the FileProcessorHandler. Deprecated cloud provider task handlers are now routed to their respective provider packages, and the colored log formatter has been updated to support timezone-aware output.
airflow-core/src/airflow/utils/log · high confidence
Metrics and tracing code consolidated into the observability package
The metrics and tracing implementation has been reorganized under the new \airflow.observability\ package. This change introduces a factory in \stats\_utils.py\ that selects the appropriate logger (StatsD, Datadog, or OpenTelemetry) based on configuration, and provides a compatibility layer in \stats.py\ that re-exports core stats functions (like \incr\, \decr\, \gauge\) from the shared implementation. Users relying on the previous import paths for these stats utilities will need to update their imports to use the new \airflow.observability.stats\ module. Also in this area: REST API metrics, clearer DAG draining state, and safer task clearing.
airflow-core/src/airflow/observability/metrics · high confidence
Microsoft MSSQL provider now requires Airflow 2.11.0 and adds URI validation
The Microsoft MSSQL provider has been updated to require Apache Airflow 2.11.0 or later, enforcing this via a runtime check in the package's \\_\init\\_.py\. Additionally, the provider now includes asset URI validation and sanitization for the \mssql://\ scheme, ensuring that URIs contain a host, a default port of 1433 if omitted, and the required database, schema, and table/view path components. This change also introduces a custom SQL dialect that handles primary key detection and generates optimized MERGE statements for upserts.
providers/microsoft/mssql · high confidence
Microsoft WinRM provider restructured for Airflow 2.11+ with deferrable operator support
The Microsoft WinRM provider has been restructured to require Apache Airflow 2.11.0 or later, moving its core components (WinRMOperator, WinRMHook, and WinRMCommandOutputTrigger) to the new provider layout and adopting the Task SDK for base classes. This update introduces deferrable mode for the WinRMOperator, allowing long-running remote commands to run asynchronously without blocking workers, and adds new parameters such as \working\_directory\ and \expected\_return\_code\ to the operator for greater control over command execution.
providers/microsoft/winrm · high confidence
Move core API logic to airflow-core and refine health, task marking, and DAG triggering
The common API implementation files (airflow\_health, delete\_dag, mark\_tasks, trigger\_dag) have been moved into the airflow-core package. The health endpoint now distinguishes between liveness and detailed coverage status for schedulers, triggerers, and DAG processors, including multi-team support for triggerers. Task marking logic has been updated to correctly include setup and teardown tasks when clearing or marking tasks, and to mark DAG runs as success when no teardown tasks are running. DAG triggering now validates that configuration is a JSON object or null, supports partition keys for partition-driven scheduling, and allows restricting allowed run types per DAG.
airflow-core/src/airflow/api/common · high confidence
MySQL provider updated to require Airflow 2.11+ and migrated to new provider structure
The MySQL provider now requires Apache Airflow 2.11.0 or later, enforcing this via a runtime check in the package initialization. The provider has been restructured to align with the new provider layout, introducing support for AIP-60 assets with \mysql\ and \mariadb\ URI schemes, which enables automatic asset creation and OpenLineage dataset conversion. Additionally, the MySQL hook now integrates with the common SQL lineage SDK to send SQL hook lineage information.
providers/mysql · high confidence
Neo4j provider restructured for Airflow 3.0 with new sensor and renamed operator parameter
The Neo4j provider has been migrated to the new provider structure and updated to require Apache Airflow 2.11.0 or later. The \Neo4jOperator\ now uses a \cypher\ parameter instead of the deprecated \sql\ parameter, with backward compatibility maintained via a deprecation warning. A new \Neo4jSensor\ has been added to allow polling Neo4j queries until a condition is met. The provider also includes updated base class imports from \airflow.providers.common.compat.sdk\ to ensure compatibility with Airflow 3.0.
providers/neo4j · high confidence
New DAG details layout with breadcrumb navigation and run switching
The DAG details page now uses a new layout structure in the \Details\ directory, introducing a \DagBreadcrumb\ component that displays a hierarchical navigation path (Dag → Run → Task) with state badges. Users can switch between different DAGs and DAG runs directly from the breadcrumb using \DagSwitcherButton\ and \DagRunSwitcherButton\ components, which provide search and selection capabilities without requiring a full page reload. The layout also includes \PanelButtons\ for view switching (Grid, Gantt, Graph) and filtering, along with \GridFilters\ for run state, type, and user filtering. This change restructures the UI to provide a more intuitive navigation experience within the DAG details context.
airflow-core/src/airflow/ui/src/layouts/Details · high confidence
New Dag Actions UI components and enhanced backfill form behavior
The Dag Actions area now includes dedicated UI components for deleting DAGs (DeleteDagButton), marking DAGs as favorites (FavoriteDagButton), and re-parsing DAG files (ParseDagButton). The Run Backfill form has been updated to default the 'run\_on\_latest\_version' setting to True, ensuring backfills use the latest DAG code unless explicitly changed. For partitioned DAGs, the form now displays a paginated partition preview table instead of a simple list, improving usability when many partitions are involved. Additionally, the form now correctly handles date-only inputs for the date range and provides clearer feedback on paused DAG actions, allowing users to choose whether to drain or keep the DAG paused when running a backfill.
airflow-core/src/airflow/ui/src/components/DagActions · high confidence
New ESLint configuration for the Airflow UI
The Airflow UI now enforces a comprehensive set of linting rules to improve code quality and consistency. This includes strict TypeScript and React standards, accessibility checks via jsx-a11y, and import sorting via eslint-plugin-perfectionist. Internationalization is strengthened with rules that prevent literal strings in JSX and ensure translation files remain complete and sorted. Additionally, a custom rule prevents the use of rem units in JSX component props to ensure Safari compatibility. Also in this area: 13 commits (1 fix) modifying airflow-core.
airflow-core/src/airflow/ui/rules · medium confidence · unverified
New JWT refresh and team-scoped authorization middlewares
This change introduces two new FastAPI middleware components in the auth layer. The JWTRefreshMiddleware automatically refreshes expired JWT tokens for authenticated users, ensuring seamless session continuity, and clears stale root-path cookies to prevent redirect loops. Additionally, the TeamAuthorizationMiddleware enforces team-based access control on plugin sub-applications, ensuring that only users authorized for a specific team can access that team's plugin endpoints.
_airflow-core/src/airflow/api\fastapi/auth/middlewares · high confidence
New React Query hooks for bulk operations and grid cache management
The UI now uses dedicated React Query hooks to handle bulk actions (clearing, deleting, and marking as success/failed for DAG runs, connections, variables, and task instances) and to manage grid view cache invalidation. These hooks ensure that after a bulk mutation, the relevant query caches are correctly invalidated so the UI reflects the latest state without stale data.
airflow-core/src/airflow/ui/src/queries · high confidence
New UI API routes and default authentication requirement
The Airflow UI API is now served through a dedicated router group under the /ui prefix, consolidating endpoints for assets, auth, backfills, calendar, config, connections, DAGs, dashboard, deadlines, dependencies, execution, Gantt, grid, partitioned DAG runs, structure, and teams. A critical behavioral change is that every route in this group now requires an authenticated user by default via the get\_user dependency, preventing accidental exposure of unauthenticated UI data.
_airflow-core/src/airflow/api\_fastapi/core\api/routes/ui · high confidence
New base auth manager implementation in airflow-core
The authentication manager base classes and models have been moved into the airflow-core package under airflow-core/src/airflow/api\_fastapi/auth/managers. This introduces a new BaseAuthManager that handles JWT token generation, validation, and revocation, along with specific exception handling for expired refresh tokens. The diff shows the foundational structure for FastAPI-based authentication, including resource method enums (GET, POST, PUT, DELETE, MENU) and user serialization/deserialization hooks, establishing the core logic for how users are authenticated and authorized within the API server.
_airflow-core/src/airflow/api\fastapi/auth/managers · high confidence
New centralized configuration templates and schema in airflow-core
The \airflow-core\ package now includes a dedicated \config\_templates\ directory containing the canonical configuration definitions. This introduces a new \config.yml\ file that serves as the single source of truth for all configuration options, accompanied by a \config.yml.schema.json\ for validation. The previous \default\_airflow.cfg\ has been replaced by a documentation-only placeholder directing users to generate configuration via the \airflow config list --defaults\ command. Additionally, new files provide structured defaults for logging (\airflow\_local\_settings.py\), the webserver (\default\_webserver\_config.py\), provider fallbacks (\provider\_config\_fallback\_defaults.cfg\), and unit tests (\unit\_tests.cfg\), centralizing how Airflow manages its configuration structure and defaults.
_airflow-core/src/airflow/config\templates · high confidence
New timetable implementations and scheduling behaviors
This change introduces several new timetable classes and fixes existing scheduling logic. It adds \AssetOrTimeSchedule\ and \AssetAndTimeSchedule\ to combine time-based and asset-based triggers, and \EventsTimetable\ for irregular event-driven runs. It also introduces \PartitionedAtRuntime\ for partition-based scheduling. Several bugs are fixed: \ContinuousTimetable\ no longer false-triggers when the last run ends in the future, manual runs no longer get zero-length data intervals across DST boundaries, and cron timetables are now hashable. Additionally, cron expression descriptions now correctly handle Day-of-Month and Day-of-Week conflicts, and the \@once\ start\_date defaults to 'now' when None. Also in this area: Asset-triggered DAGs now create one run per event by default.
airflow-core/src/airflow/timetables · high confidence
New trigger module with deprecation warnings and testing utilities
The airflow-core package now includes a new \airflow.triggers\ module. This module introduces \CallbackTrigger\ for executing callback functions asynchronously, supporting optional context injection and queue configuration. It also provides \SuccessTrigger\ and \FailureTrigger\ for testing purposes. Additionally, it establishes deprecation warnings for legacy trigger classes (\WorkflowTrigger\, \DagStateTrigger\, \FileTrigger\, \DateTimeTrigger\, \TimeDeltaTrigger\), directing users to their new locations in \airflow.providers.standard.triggers\.
airflow-core/src/airflow/triggers · high confidence
ODBC provider now requires Airflow 2.11.0 and adds driver-in-extra configuration
The ODBC provider has been updated to require Apache Airflow 2.11.0 or later, enforcing this via a runtime check in the package initialization. Additionally, the provider now supports reading the ODBC driver name from the connection's extra field, controlled by the new \allow\_driver\_in\_extra\ configuration option in the \providers.odbc\ section (defaulting to False for security).
providers/odbc · high confidence
Opsgenie provider upgraded to require Airflow 2.11+ and adopt the Task SDK
The Opsgenie provider now requires Apache Airflow 2.11.0 or later, enforcing this via a runtime check in the package metadata. Under the hood, the provider has been migrated to the new provider structure, replacing the legacy \BaseOperator\ and \BaseHook\ with their Task SDK equivalents (\airflow.providers.common.compat.sdk\). This structural update also introduces a dedicated \CreateAlertPayload\ TypedDict for type-safe alert creation and updates the connection UI metadata to hide unnecessary fields (port, schema, login, extra) while relabeling the password field as 'Opsgenie API Key'.
providers/opsgenie · high confidence
PagerDuty provider upgraded to require Airflow 2.11+ and adds async notification support
The PagerDuty provider now requires Apache Airflow 2.11.0 or later, enforced by a runtime check in the package initialization. The provider has been migrated to the new provider structure, introducing a \get\_provider\_info.py\ file that defines connection metadata and UI field behavior for both the PagerDuty API and Events connections. A new \PagerdutyNotifier\ has been added to support task notifications, featuring both synchronous and asynchronous execution paths via \notify\ and \async\_notify\ methods. The underlying hooks (\PagerdutyHook\ and \PagerdutyEventsHook\) have been updated to use the \pagerduty\ library instead of \pdpyras\ and now inherit from \BaseHook\ in the Task SDK, with connection handling simplified to use the \password\ field directly.
providers/apprise, providers/pagerduty · high confidence
PgVector provider now requires Airflow 2.11+ and supports psycopg3
The pgvector provider has been restructured and now enforces a minimum Apache Airflow version of 2.11.0. The provider's hook and operators have been updated to support psycopg3 as the default synchronous Postgres driver, with the \PgVectorIngestOperator\ automatically registering the pgvector data type for both psycopg3 and psycopg2 connections.
providers/pgvector · high confidence
Pinecone provider now requires Airflow 2.11.0 and drops legacy project\_id support
The Pinecone provider has been updated to require Apache Airflow 2.11.0 or later, enforcing this constraint at import time. Additionally, the provider now relies on the Pinecone SDK v7+, which removes the \project\_id\ argument from the client constructor; the provider code has been adjusted to stop passing this argument, meaning any \project\_id\ values stored in existing connections are now ignored rather than causing errors.
providers/pinecone · high confidence
Pools page rewritten with new UI components and features
The Pools management page has been completely rewritten to use a new card-based layout (PoolBarCard) instead of the previous table view, featuring improved slot visualization, support for unlimited slots (displayed as ∞), and the ability to assign pools to teams via a TeamSelector when multi-team is enabled. The page now includes dedicated Add, Edit, and Delete buttons with modal dialogs, supports sorting by name, and integrates with the new DataTable and SearchBar components for filtering and pagination.
airflow-core/src/airflow/ui/src/pages/Pools · high confidence
Presto provider now requires Airflow 2.11+ and adds Asset support for URI-based data discovery
The Presto provider has been restructured for Airflow 3.0 compatibility, raising the minimum supported Airflow version to 2.11.0 (previously 2.10). This update introduces native Asset support for the \presto://\ URI scheme, enabling automatic data discovery and lineage via new \sanitize\_uri\, \create\_asset\, and \to\_openlineage\_converter\ handlers. The provider also migrates to the common compatibility SDK, updating the \PrestoHook\ to use \get\_df\ and ensuring consistent context variable handling across Airflow versions.
providers/presto · high confidence
Public API routes restructured into a unified FastAPI router
The public API routes in \airflow-core/src/airflow/api\_fastapi/core\api/routes/public\ have been reorganized into a single \\\init\\_.py\ file that registers all route modules (such as assets, backfills, connections, and dag\_runs) under a centralized \authenticated\_router\. This router applies a default \Depends(get\_user)\ dependency to enforce authentication across all endpoints, serving as a defense-in-depth measure to ensure no route is accidentally exposed without an auth check. Individual routes still maintain their own fine-grained authorization dependencies, while non-authenticated routes like \monitor\, \version\, and \auth\ are included separately in the public router.
_airflow-core/src/airflow/api\_fastapi/core\api/routes/public · high confidence
Redesigned DAG details page with improved status visibility and error handling
The DAG details page has been rebuilt to provide a clearer view of DAG state and configuration. The new header displays active run counts against the maximum limit, shows a 'draining' badge for graceful pauses, and hides the next run timestamp for paused or stale DAGs. A dedicated Details tab now exposes configuration fields such as last parse duration, default arguments, and team ownership. The page also handles missing DAGs gracefully with a 404 view and includes a badge to display deadline alerts.
airflow-core/src/airflow/ui/src/pages/Dag · high confidence
Refactored Task Instance 'Mark As' UI with keyboard shortcuts and regional scope handling
The Task Instance 'Mark As' interface has been consolidated into a new button and dialog component pair. The button now exposes a menu of target states (including 'skipped' where allowed) and supports keyboard shortcuts for marking tasks as 'success' or 'failed'. The accompanying dialog has been updated to correctly handle regional task instances (loops) by disabling cross-run scope options (past/future) and targeting specific region IDs, while also ensuring that 'downstream' is not selected by default and that skipping is strictly limited to the single selected task instance.
airflow-core/src/airflow/ui/src/components/MarkAs/TaskInstance · high confidence
Refactored clear task instance dialogs with new UI components and versioning logic
The clear task instance UI has been restructured into a new component hierarchy within the TaskInstance clear folder. This includes a new ClearGroupTaskInstanceDialog for clearing task groups, a ClearTaskInstanceButton that acts as a unified entry point for single, mapped, or group clears, and a ClearTaskInstanceConfirmationDialog that gates clears on running tasks. The logic for the 'Run on Latest Version' option has been extracted into a dedicated hook (useRerunWithLatestVersion) and utility (runOnLatestVersion), which now handles precedence between user overrides, DAG-level config, global config, and fallbacks, and correctly determines when to show or force the option based on bundle and DAG version differences. Tests have been added to cover these new components and the versioning logic.
airflow-core/src/airflow/ui/src/components/Clear/TaskInstance · high confidence
Regenerated UI API client queries
The React Query hooks and data-fetching utilities in the UI's OpenAPI-generated client have been regenerated to align with the latest backend API specification. This update ensures that the frontend's data access layer (including query keys, prefetching, and suspense hooks) correctly reflects current endpoint signatures, parameters, and response types.
airflow-core/src/airflow/ui/openapi-gen/queries · high confidence
Regenerated UI API client with updated schemas and services
The auto-generated TypeScript client in the UI's \openapi-gen/requests\ directory has been regenerated to align with the latest REST API changes. This update refreshes the \schemas.gen.ts\ definitions to include new fields such as \consumer\_teams\ for asset event access control and \partition\_key\ for asset events, while \services.gen.ts\ now exposes the full set of UI-specific endpoints (including backfills, deadlines, and state stores) and \types.gen.ts\ provides the corresponding TypeScript interfaces. Users benefit from accurate type checking and complete method signatures for all current Airflow UI API interactions.
airflow-core/src/airflow/ui/openapi-gen/requests · high confidence
Remote logging now uses shared I/O classes
The remote logging module in airflow-core now delegates to the shared \RemoteLogIO\ and \RemoteLogStreamIO\ classes from the task SDK. This change decouples the core logging implementation from the task SDK, allowing the core to rely on the shared I/O interfaces for remote log access and streaming.
airflow-core/src/airflow/logging · high confidence
Restructured contributing documentation into a modular, multi-file guide
The single, monolithic contributing guide has been split into a structured set of RST files (e.g., roles, communication, quick start, pull requests) to improve navigation and readability. This reorganization introduces a dedicated beginner's quick start for first-time contributors, clarifies the new 'no assignment' policy for issues, and updates local development instructions to recommend \uv\ and \prek\ over legacy tools.
contributing-docs · high confidence
SFTP provider version 7.0.0 requires Airflow 2.11+
The SFTP provider has been updated to version 7.0.0, which enforces a minimum Apache Airflow version of 2.11.0. Attempting to use this provider with earlier Airflow versions will now raise a runtime error. This change accompanies a structural migration of the provider to the new package layout, introducing new modules for assets, decorators, filesystems, and exceptions, while retaining core functionality in hooks, operators, sensors, and triggers.
providers/cncf/kubernetes, providers/sftp, providers/ssh · high confidence
Salesforce provider now requires Airflow 2.11.0 and adds transient-error retries to the Bulk Operator
The Salesforce provider has been updated to require Apache Airflow 2.11.0 or later, enforced by a runtime check in the provider's \\_\init\\_.py\. Additionally, the \SalesforceBulkOperator\ now supports automatic retries for transient server-side errors (such as \UNABLE\_TO\_LOCK\_ROW\ and \API\_TEMPORARILY\_UNAVAILABLE\) via new \max\_retries\, \bulk\_retry\_delay\, and \transient\_error\_codes\ parameters, allowing workflows to recover from temporary Salesforce API issues without manual intervention.
providers/salesforce · high confidence
Samba provider requires Airflow 2.11+ and adds Kerberos auth and Windows path support
The Samba provider now enforces a minimum Apache Airflow version of 2.11.0, raising a runtime error if an older version is detected. The SambaHook now supports Kerberos authentication via the \auth\_protocol\ connection field (requiring the optional \krb5\ dependency) and correctly handles Windows-style file paths when the connection's \share\_type\ is set to \windows\. Additionally, the GCSToSambaOperator now validates that resolved destination paths remain within the configured \destination\_path\ to prevent directory traversal.
providers/samba · high confidence
Secrets backends moved to airflow-core with team-scoped environment variable support
The secrets framework implementation has been relocated into the airflow-core package, introducing a new module structure (airflow.secrets) that exposes BaseSecretsBackend, EnvironmentVariablesBackend, MetastoreBackend, and LocalFilesystemBackend. This change adds support for team-scoped secrets via environment variables: when multi-team mode is enabled, secrets can be namespaced using the format AIRFLOW\CONN\\\<TEAM\>\\\\<ID\> or AIRFLOW\VAR\\\<TEAM\>\\\\<KEY\>, and the backends now enforce team boundaries to prevent cross-team access. The EnvironmentVariablesBackend checks for team-specific variables before falling back to global ones, and the MetastoreBackend queries connections and variables with team\_name filtering. Deprecated imports like SecretCache and DEFAULT\_SECRETS\_SEARCH\_PATH\_WORKERS are handled with warnings directing users to the Task SDK equivalents.
airflow-core/src/airflow/secrets · high confidence
Security module relocated to airflow-core with permissions deprecation
The security-related source files (kerberos, permissions, utils) have been moved into the new airflow-core package. The airflow.security.permissions module now emits a RemovedInAirflow4Warning to indicate it is deprecated, and the kerberos implementation has been updated to support configurable renewable lifetime for Heimdal Kerberos.
airflow-core/src/airflow/security · high confidence
Segment provider requires Airflow 2.11+ and uses new compatibility layer
The Segment provider now enforces a minimum Apache Airflow version of 2.11.0, raising a runtime error if an older version is detected. Internally, the provider has migrated to the new Airflow 3+ compatibility structure, importing base classes like \BaseHook\ and \BaseOperator\ from \airflow.providers.common.compat.sdk\ and utilizing a \version\_compat\ module to handle version-specific logic. This ensures the provider remains compatible with modern Airflow architectures while maintaining backward compatibility for version detection.
providers/segment · high confidence
Sensor classes deprecated and relocated to providers and SDK
The sensor classes previously available directly under \airflow.sensors\ (such as \BaseSensorOperator\, \PythonSensor\, \BashSensor\, and various date/time/file sensors) are now deprecated. Users importing these classes from \airflow.sensors\ will receive deprecation warnings directing them to the new locations: base sensor logic has moved to \airflow.sdk.bases.sensor\, while specific implementations like \PythonSensor\ and \BashSensor\ have been moved to the \airflow.providers.standard\ package.
airflow-core/src/airflow/sensors · high confidence
Shared DAG node and cycle detection logic moved to core library
The DAG node implementation and cycle detection algorithm have been moved from the Task SDK into the shared \airflow\_shared.dagnode\ core library. This change centralizes the graph traversal logic, making the \detect\_cycle\ function and the \GenericDAGNode\ base class available to both the core Airflow engine and the SDK without duplication. Users benefit from a unified, consistent implementation of DAG graph operations and cycle validation across the platform.
shared/dagnode · high confidence
Shared listener infrastructure with OpenTelemetry tracing
The listeners module has been moved to the shared library to support client-server separation, introducing a centralized \ListenerManager\ that uses \pluggy\ for hook registration and execution. This change adds automatic OpenTelemetry span generation around listener hook calls, allowing users to trace listener execution in their observability dashboards. The shared package also defines lifecycle hooks (\on\_starting\, \before\_stopping\) and task instance hooks (\on\_task\_instance\_running\, \on\_task\_instance\_success\, \on\_task\_instance\_failed\, \on\_task\_instance\_skipped\) that components can now register against.
shared/listeners · high confidence
Shared logging module introduces structlog-based configuration and remote handler resolution
The shared/logging package now provides the core infrastructure for Airflow's logging system, centering on a migration to structlog. This includes a new PercentFormatRender processor that allows users to retain familiar stdlib-style percent-format log strings while benefiting from structlog's structured capabilities, and a factory module that resolves remote logging handlers via a three-tier precedence (user-defined config class, provider dispatch, legacy fallback). The module also exposes configuration translation for log formats and callsite parameters, defines the RemoteLogIO protocol for provider-backed remote storage, and implements runtime fixes such as non-caching file I/O and a pathlib memory-leak patch for long-running processes.
shared/logging · high confidence
Simple Auth Manager UI regenerated with OpenAPI codegen
The Simple Auth Manager UI has been regenerated using the @7nohe/openapi-react-query-codegen tool (version 3.0.2). This update refreshes the auto-generated TypeScript files for API requests and React Query hooks, ensuring the client-side authentication logic aligns with the current backend API schema.
_airflow-core/src/airflow/api\fastapi/auth/managers/simple/ui · high confidence
Simple auth manager moves to airflow-core with FastAPI integration
The SimpleAuthManager implementation has been relocated from the Airflow provider package into the airflow-core package, now residing under airflow-core/src/airflow/api\_fastapi/auth/managers/simple. This change introduces a new FastAPI-based authentication flow, including a login endpoint that accepts JSON or form bodies, a middleware (SimpleAllAdminMiddleware) to automatically grant admin access when configured, and a warning system that alerts users if the simple auth manager is running in a production-like environment. The user model now supports multi-team associations, and the password generation logic uses a cryptographically secure RNG.
_airflow-core/src/airflow/api\fastapi/auth/managers/simple · high confidence
SimpleAuthManager login routes moved to airflow-core
The login endpoint implementations for the SimpleAuthManager have been relocated to the airflow-core package. This change consolidates the authentication route definitions (including token creation and admin login redirects) within the core API module, ensuring they are bundled with the main Airflow distribution rather than being scattered in separate source locations.
_airflow-core/src/airflow/api\fastapi/auth/managers/simple/routes · high confidence
Standalone shared timezone library with pendulum 3 compatibility
The shared/timezones module has been refactored into a standalone library that removes dependencies on internal Airflow imports, allowing it to be used independently. It now explicitly supports pendulum 3 by detecting the library version and adjusting the UTC timezone instance accordingly, ensuring consistent time handling across different pendulum versions.
shared/timezones · high confidence
Standard decorators are deprecated in favor of the SDK
The decorator classes and functions previously available in \airflow.decorators\ (such as \@task\, \@dag\, \@task\_group\, and related base classes) are now deprecated. Users should migrate their imports to the corresponding implementations in \airflow.sdk\ (e.g., \from airflow.sdk import task\). The module now acts as a compatibility shim that redirects these imports to the SDK while emitting deprecation warnings, ensuring existing code continues to function during the transition.
airflow-core/src/airflow/decorators · high confidence
Standardized Java SDK build conventions and publishing configuration
The Java SDK build process now uses centralized Gradle convention plugins to enforce consistent JVM settings and release artifacts. The new \airflow-jvm-conventions\ plugin standardizes the build to Java 11, applies code formatting via Spotless, and ensures that LICENSE and NOTICE files are included in JAR metadata. Additionally, the \airflow-publish\ plugin centralizes Maven publishing logic, automatically configuring group IDs, POM metadata, repository credentials, and PGP signing for all subprojects, ensuring reproducible and compliant artifact generation.
java-sdk/buildSrc · high confidence
Tableau provider now requires Airflow 2.11.0 and adds incremental refresh support
The Tableau provider has been updated to require Apache Airflow 2.11.0 or later, enforcing this constraint at import time. For users running extract refreshes, the TableauOperator now supports incremental refreshes via a new \incremental\_refresh\ parameter, which passes the \incremental=True\ flag to the underlying Tableau Server API. Additionally, the operator can now skip tasks instead of failing when encountering a Tableau 409093 resource conflict (e.g., when a refresh is already queued or running) by setting \skip\_on\_conflict=True\. The provider also introduces JWT authentication support in the hook, allowing users to authenticate using a JWT token or file, and migrates the operator and sensor to use the Task SDK base classes.
providers/tableau · high confidence
Task Instance page receives a comprehensive UI overhaul with new tabs and improved detail views
The Task Instance detail page has been restructured into a tabbed interface, introducing dedicated views for Asset Events, Blocking Dependencies, and Human-in-the-Loop (HITL) responses. The main Details tab now supports selecting specific task tries to view historical state reasons and loop iteration context, while the Header displays a state reason alert for failed or retried tasks. Additionally, the Rendered Templates tab now formats code blocks with proper line wrapping to prevent copy-paste errors, and the Extra Links component automatically targets internal links within the same window while opening external links in new tabs.
airflow-core/src/airflow/ui/src/pages/TaskInstance · high confidence
Task and Task Group detail pages now display loop iteration stats and documentation
The Task and Task Group detail pages have been updated to show loop iteration statistics (via the new \useLoopRuleStats\ hook) in the header card, giving users immediate visibility into loop outcomes. Additionally, both individual tasks and task groups now feature a dedicated documentation button that displays markdown content when available, and the Task Group header specifically supports this new documentation view alongside the loop stats.
airflow-core/src/airflow/ui/src/pages/Task · high confidence
Task groups now expand by default based on user preference
The DAG graph view now respects a new user setting to automatically expand task groups when the structure loads. If the 'default task groups expanded' preference is enabled, all groups will be open by default; otherwise, they remain collapsed. This behavior can be overridden by manually expanding or collapsing specific groups, which saves the selection to local storage and persists across sessions.
airflow-core/src/airflow/ui/src/context/groups · high confidence
Task scheduling logic moved to airflow-core
The \PriorityWeightStrategy\ interface, \TriggerRule\ enum, and \WeightRule\ enum have been relocated from \airflow.utils\ to the \airflow.task\ package within the \airflow-core\ distribution. This change consolidates core task scheduling components, making them directly accessible via \airflow.task\ and integrating them with the Execution API schema for task priority and trigger rule handling.
airflow-core/src/airflow/task · high confidence
Telegram provider now requires Airflow 2.11+ and uses Task SDK base classes
The Telegram provider has been updated to require Apache Airflow 2.11.0 or later, enforcing this via a runtime check in the package initialization. To support this version requirement, the \TelegramHook\ and \TelegramOperator\/\TelegramFileOperator\ classes now inherit from the Task SDK's \BaseHook\ and \BaseOperator\ (imported via \airflow.providers.common.compat.sdk\) instead of the legacy base classes. This migration ensures compatibility with Airflow 3.0+ while maintaining functionality for current users on 2.11+.
providers/mongo, providers/telegram · high confidence
Trino provider now requires Apache Airflow 2.11.0+ and enforces single authentication method
The Trino provider has been updated to require Apache Airflow 2.11.0 or later, raising the minimum version from the previous 2.10.0 threshold. Additionally, the TrinoHook now enforces that only one authentication method (password, JWT, certificate, or Kerberos) can be specified per connection; attempting to configure multiple methods simultaneously will now raise an error instead of potentially ambiguous behavior.
providers/trino · high confidence
UI color mode now supports system preference and syncs Monaco editor themes
The Airflow UI now respects the operating system's light/dark setting in addition to manual selection, allowing the interface to automatically adapt to the user's system theme. This change also ensures that the Monaco code editor within the UI matches the Chakra UI color palette by defining custom 'airflow-light' and 'airflow-dark' themes that dynamically map Chakra CSS variables to editor colors.
airflow-core/src/airflow/ui/src/context/colorMode · high confidence
UI layout restructuring and RTL support
The UI layout system has been restructured to support right-to-left (RTL) languages and improved responsiveness. The BaseLayout component now dynamically sets the document direction and language attributes based on the active locale, ensuring correct text alignment for RTL users. Additionally, the main content area now uses logical margins (margin-left for LTR, margin-right for RTL) to align properly with the navigation sidebar regardless of text direction. A new DagsLayout component centralizes navigation tabs for DAGs, DAG runs, and task instances, while the BaseLayout also integrates keyboard shortcut help and favicon theme customization.
airflow-core/src/airflow/ui/src/layouts · high confidence
UI timezone selection now persists in browser local storage
The Airflow UI now remembers your chosen timezone across page reloads and browser sessions. Instead of relying on a server-side default configuration, the interface detects your system's timezone and saves your selection to the browser's local storage, ensuring your preferred view is consistent every time you visit.
airflow-core/src/airflow/ui/src/context/timezone · high confidence
Updated Simple Auth Manager OpenAPI schema to version 3.1
The generated OpenAPI specification for the Simple Auth Manager has been updated to OpenAPI 3.1.0, replacing the previous version. This change aligns the schema with the latest FastAPI standards, ensuring that API documentation and client generation tools reflect the current structure of the authentication endpoints (such as token creation and login).
_airflow-core/src/airflow/api\fastapi/auth/managers/simple/openapi · high confidence
Variables management UI refactored with JSON validation and team support
The Variables management interface has been rebuilt using new system components, introducing a dedicated form for adding, editing, and deleting variables. A key behavioral change is the addition of client-side JSON validation: if a variable value starts with '{' or '\[', the form checks if it is valid JSON and displays a prominent warning (without blocking the save) if it is malformed, allowing users to save Jinja templates or plain strings that merely resemble JSON. Additionally, when multi-team features are enabled, a team selector is now available in the variable form, and the edit dialog preserves the original formatting of JSON values for better readability.
airflow-core/src/airflow/ui/src/pages/Variables/ManageVariable · high confidence
Vertica provider restructured with SQLAlchemy as optional and new asset support
The Vertica provider has been restructured to require Apache Airflow 2.11.0 or later and now treats SQLAlchemy as an optional dependency, raising a clear error if the library is missing when SQLAlchemy features are used. It also introduces support for Airflow Assets by registering URI sanitizers, asset factories, and OpenLineage converters for the vertica:// scheme, enabling data lineage and asset-based triggering for Vertica tables.
providers/vertica · high confidence
Weaviate provider restructured for Airflow 3.0 compatibility
The Weaviate provider has been migrated to the new Airflow 3.0 provider structure, introducing a \version\_compat\ module to handle version-specific logic and updating the hook and operators to inherit from \BaseHook\ and \BaseOperator\ in \airflow.providers.common.compat.sdk\. The provider now enforces a minimum Apache Airflow version of 2.11.0, and connection metadata (including UI field behavior and connection types) is managed via a new \get\_provider\_info.py\ file.
providers/weaviate · high confidence
Yandex provider upgraded to require Airflow 2.11+ and migrated to the new SDK-based architecture
The Yandex provider now requires Apache Airflow 2.11.0 or later, enforcing this via a runtime check in the package metadata. Under the hood, the provider has been refactored to use the new Airflow SDK: hooks and operators now inherit from \airflow.providers.common.compat.sdk\ base classes, and the connection UI metadata has been migrated to a structured \get\_provider\_info\ definition. This update also introduces multi-team namespace support in the Lockbox secrets backend, which now refuses access to secrets if the ID implies a team scope that the user is not authorized to access.
providers/yandex · high confidence
Zendesk provider now requires Airflow 2.11+ and supports API/OAuth tokens
The Zendesk provider has been updated to require Apache Airflow 2.11.0 or later, enforcing this via a runtime check in the package initialization. Functionally, the provider now supports API tokens and OAuth tokens in addition to the legacy password method, allowing users to authenticate using a dedicated API token field, an OAuth token, or by treating the password field as an API token. The Connection UI has been updated to reflect these new authentication options, hiding the schema and port fields and relabeling the host and login fields for clarity.
providers/zendesk · high confidence
gRPC provider now requires Airflow 2.11.0+ and uses SDK BaseHook
The gRPC provider has been updated to require Apache Airflow 2.11.0 or later, enforcing this via a runtime check in the provider's \_\init\\_.py. Additionally, the GrpcHook and GrpcOperator now inherit from the SDK-based BaseHook and BaseOperator classes (imported from airflow.providers.common.compat.sdk) instead of the legacy Airflow base classes, aligning the provider with the new task SDK architecture.
providers/grpc · high confidence
Fixes
Introduce shared serialization constants for backward compatibility
The shared serialization module now defines explicit constants for both current and legacy serialization format keys (such as \_\classname\\, \\version\\, and legacy type markers like \\_type). It also includes a mapping to resolve old-style builtin type names (e.g., 'tuple', 'datetime') to their full qualified names, enabling the system to correctly deserialize trigger kwargs and other data that were persisted using older serialization formats.
shared/serialization · high confidence
Test coverage
6 commits adding/updating tests in airflow-core/tests/unit/api\_fastapi/execution\_api/versions/v2027\_02\_28; Add multi-language KubernetesExecutor system tests for Go, Java, and TypeScript; Added E2E test infrastructure and documentation for the Airflow UI; Added E2E tests for UI pages and components; Added Java streaming source for Dataflow system tests; Added Java task handlers for mixed-language Kubernetes system tests; Added Task SDK integration tests for asset, connection, DAG run, and variable operations; Added docker-tests suite for validating Airflow container images; Added integration tests for Celery worker, OpenTelemetry, and Kerberos; Added integration tests for Kafka provider event listeners; Added system test infrastructure and example; Added test infrastructure for Google and OpenLineage providers; Added tests for API route authentication, error handling, and OpenAPI spec consistency; Added tests for BaseUser.get\_display\_name fallback behavior; Added tests for Execution API v2026-06-30 backward compatibility; Added tests for FastAPI authentication token generation and validation; Added tests for FastAPI core API security, configuration, and session management; Added tests for JWT refresh and team authorization middlewares; Added tests for ObjectStoragePath wrapper lineage tracking; Added tests for REST API datamodel validation and serialization; Added tests for Simple Auth Manager login service; Added tests for SimpleAuthManager login and token routes; Added tests for UI services: connection metadata, DAG run duration, execution members, and grid node merging; Added tests for audit log sanitization and masking; Added tests for config template handling of remote logging kwargs and OpenSearch port defaults; Added tests for database migration integrity and anti-patterns; Added tests for execution API health routes; Added tests for observability metrics and stats configuration; Added tests for serialized asset definitions, variable intervals, and duration params; Added tests for shared configuration, DAG node, listener, and logging libraries; Added tests for the Metastore state backend; Added tests for trigger template rendering, callback execution, and shared-stream polling; Added unit test fixtures for Airflow core; Added unit test fixtures for DAG parsing and execution scenarios; Added unit tests for API FastAPI common utilities; Added unit tests for Airflow API common modules; Added unit tests for Airflow CLI commands; Added unit tests for Airflow core models and decorators; Added unit tests for CLI parser validation, hot-reload, and utility functions; Added unit tests for DAG bundle management and base bundle logic; Added unit tests for DAG list query handling of QUEUED runs; Added unit tests for DAG processing components; Added unit tests for DAG serialization and deserialization; Added unit tests for Kerberos, permissions, and deprecation warnings; Added unit tests for airflow-core configuration, settings, and core components; Added unit tests for asset evaluation and management; Added unit tests for callback request serialization and DAG run context; Added unit tests for cluster policies module; Added unit tests for executor components; Added unit tests for logging configuration and remote task log handling; Added unit tests for partition mapper components; Added unit tests for task instance dependency checks; Added unit tests for the Execution API head version; Added unit tests for the Simple Auth Manager; Added unit tests for the base auth manager; Added unit tests for the listener subsystem; Added unit tests for the plugin system; Java SDK processor registration and test coverage; New E2E page objects for Airflow UI testing; New E2E test fixtures for data isolation and Page Object Model; New E2E test utilities for API interactions and UI stability; New UI utility functions and test coverage for formatting, filtering, and language detection; New core test suite for connections, secrets, and providers; New integration test suite for airflowctl CLI commands; New mock API handlers for UI development; New test infrastructure for the FastAPI-based Airflow API; Updated test infrastructure and deprecation ignore list.
Dependencies
2458 commits updating dependencies (205 manifests)
A dependency / build maintenance change in (dependencies) — 2458 commits (234 fixs), 205 files: “Add common.compat provider (\#40374)”; “Deprecating email, email\_on\_retry, email\_on\_failure in BaseOperator (\#47146)”; “Fix ts-compile-lint-simple-auth-manager-ui prek hook (\#64310)”; and 2454 more (refs \#40374, \#47146, \#64310, \#57383, \#68107, …).
(dependencies) · high confidence · unverified
Housekeeping
Airflow version updated to 3.4.0
The core package version has been bumped to 3.4.0, as reflected in the \\_\init\\_.py\ module. This update accompanies the introduction of new configuration schemas (such as \provider.yaml.schema.json\ and \provider\_info.schema.json\) and the addition of a metrics visualization guide (\METRICS.md\), establishing the baseline for this release cycle.
airflow-core/src/airflow · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 53 → 48 (-5.0)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 79 → 62 (-16.8)
- Architecture 68 → 66 (-1.4)
- Maturity 93 → 94 (+0.9)
- Readiness 45 → 45 (-0.3)
- Security 71 → 72 (+0.5)
- Domain Modelling 100 → 100 (+0.0)
- Accessibility 47 → 38 (-8.9)
- Performance 63 → 60 (-3.4)
Resolved (419)
- AgentOperator._require_durable_toolset_ids (cognitive 19) (providers/common/ai/src/airflow/providers/common/ai/operators/agent.py)
- AwsEcsExecutor.attempt_workload_runs (cognitive 21) (providers/amazon/src/airflow/providers/amazon/aws/executors/ecs/ecs_executor.py)
- Change coupling: AssetsList.tsx ↔ Events.tsx (airflow-core/src/airflow/ui/src/pages/AssetsList/AssetsList.tsx)
- Change coupling: cli_config.py ↔ team_command.py (airflow-core/src/airflow/cli/cli_config.py)
- Classify ADR enforcement: 1. Post-build bundle-packing options for the Go SDK (go-sdk/adr/0001-bundle-packing-options.md)
- Classify ADR enforcement: 1. Record architecture decisions (dev/breeze/doc/adr/0001-record-architecture-decisions.md)
- Classify ADR enforcement: 10. Use pipx to install breeze (dev/breeze/doc/adr/0010-use-pipx-to-install-breeze.md)
- Classify ADR enforcement: 10. Use uv tool to install breeze (dev/breeze/doc/adr/0016-use-uv-tool-to-install-breeze.md)
- Classify ADR enforcement: 11. Unified communication with the users (dev/breeze/doc/adr/0011-unified-communication-with-the-users.md)
- Classify ADR enforcement: 12. Asking user for confirmation (dev/breeze/doc/adr/0012-asking-user-for-confirmation.md)
- Classify ADR enforcement: 13. Get rid of submodules (dev/breeze/doc/adr/0013-get-rid-of-submodules.md)
- Classify ADR enforcement: 14. Fix root ownership after exiting docker command (dev/breeze/doc/adr/0014-fix-root-ownership-after-exiting-docker-command.md)
- Classify ADR enforcement: 15. Handling rootless docker (dev/breeze/doc/adr/0015-handling-rootless-docker.md)
- Classify ADR enforcement: 17. Run breeze from the current worktree's locked sources (dev/breeze/doc/adr/0017-use-uvx-to-run-breeze-from-local-sources.md)
- Classify ADR enforcement: 18. Raise the floors of fast-moving dependencies automatically (dev/breeze/doc/adr/0018-raise-dependency-floors-automatically.md)
- Classify ADR enforcement: 19. Isolate Docker resources per git worktree (dev/breeze/doc/adr/0019-isolate-docker-resources-per-git-worktree.md)
- Classify ADR enforcement: 2. Implement standalone python command (dev/breeze/doc/adr/0002-implement-standalone-python-command.md)
- Classify ADR enforcement: 2. Return common data structure from DBApiHook derived hooks (providers/common/sql/src/airflow/providers/common/sql/doc/adr/0002-return-common-data-structure-from-dbapihook-derived-hooks.md)
- Classify ADR enforcement: 2. Use the Go 1.24 tool directive to deliver the bundle packer (go-sdk/adr/0002-use-go-tool-directive-for-bundle-packer.md)
- Classify ADR enforcement: 20. Run CI for external contributions in contributor forks (dev/breeze/doc/adr/0020-run-ci-for-external-contributions-in-forks.md)
- …and 399 more
New (1151)
- AirflowTools.run (cognitive 19) (providers/common/ai/src/airflow/providers/common/ai/tools/claude_agent_sdk.py)
- AssetEventSensor.poke (cognitive 16) (providers/standard/src/airflow/providers/standard/sensors/asset.py)
- Backfills.Backfills (cognitive 17) (airflow-core/src/airflow/ui/src/pages/Dag/Backfills/Backfills.tsx)
- BaseSQLOperator.get_openlineage_facets_on_start (cognitive 16) (providers/common/sql/src/airflow/providers/common/sql/operators/sql.py)
- BaseSQLOperator.get_openlineage_facets_on_start (cyclomatic 16) (providers/common/sql/src/airflow/providers/common/sql/operators/sql.py)
- BypassFinder.find (cognitive 18) (dev/breeze/src/airflow_breeze/utils/fork_ci_reconcile.py)
- Change coupling: Header.tsx ↔ DagCard.tsx (airflow-core/src/airflow/ui/src/pages/Dag/Header.tsx)
- Change-coupling hub: AssetsList.tsx → DagsList.tsx, Events.tsx, XCom.tsx (airflow-core/src/airflow/ui/src/pages/AssetsList/AssetsList.tsx)
- CloudSqlProxyRunner.start_proxy (cognitive 17) (providers/google/src/airflow/providers/google/cloud/hooks/cloud_sql.py)
- Credentials.load (cyclomatic 16) (airflow-ctl/src/airflowctl/api/client.py)
- DagFileProcessorManager._build_parse_result (cognitive 18) (airflow-core/src/airflow/dag_processing/manager.py)
- DagFileProcessorManager._build_parse_result (cyclomatic 17) (airflow-core/src/airflow/dag_processing/manager.py)
- DagFileProcessorManager._publish_pending_results (cognitive 46) (airflow-core/src/airflow/dag_processing/manager.py)
- DagFileProcessorManager._publish_pending_results (cyclomatic 20) (airflow-core/src/airflow/dag_processing/manager.py)
- DagFileProcessorManager._sort_by_mtime (cognitive 16) (airflow-core/src/airflow/dag_processing/manager.py)
- DagFileProcessorManager.handle_parsing_result (cognitive 16) (airflow-core/src/airflow/dag_processing/manager.py)
- DagFileProcessorManager.prepare_file_queue (cyclomatic 18) (airflow-core/src/airflow/dag_processing/manager.py)
- DagModel.dags_needing_dagruns (cyclomatic 16) (airflow-core/src/airflow/models/dag.py)
- DagParseResultBody.validate_file_scope (cognitive 29) (airflow-core/src/airflow/api_fastapi/execution_api/datamodels/dag_parsing.py)
- DagParseResultBody.validate_file_scope (cyclomatic 23) (airflow-core/src/airflow/api_fastapi/execution_api/datamodels/dag_parsing.py)
- …and 1131 more
Changes since last survey
- 300 commits — 253 feature/other, 47 fixes
By area
- airflow-core/src — 72 commits
- providers/common — 28 commits
- dev/breeze — 19 commits
- providers/amazon — 13 commits
- (root) — 12 commits
- providers/google — 10 commits
- .github/workflows — 8 commits
- task-sdk/src — 8 commits
- airflow-core/docs — 7 commits
- providers/apache — 7 commits
- providers/microsoft — 7 commits
- airflow-core/tests — 6 commits
- providers/databricks — 6 commits
- providers/edge3 — 6 commits
- airflow-ctl/src — 4 commits
- chart/templates — 4 commits
- dev/react-plugin-tools — 4 commits
- providers/openlineage — 4 commits
- providers/standard — 4 commits
- .agents/skills — 3 commits
Notable commits
- fix: Add a regression test for WITH in the asset orphanage DELETE (#75127)
- fix: Fix AwsEksExecutor dying with a 401 after its credentials rotate (#76332)
- fix: Fix Celery workers rejecting deadline callbacks on Airflow 3.2 (#75438)
- fix: Fix CeleryExecutor failing to load with Celery 5.7 (#76591)
- fix: Fix Dag bundle sync losing updates when a bundle reads a connection (#76188)
- fix: Fix Databricks retry parameter names in deferrable-mode docs (#76744)
- fix: Fix Deadline Alert SmtpNotifier example in Dag docs (#75597)
- fix: Fix ExternalTaskSensor link pointing to the wrong external Dag run (#74528)
- fix: Fix FTP test connection passing without contacting the server (#76355)
- fix: Fix GcpBodyFieldValidator warning on valid version-specific fields (#74930)
- fix: Fix Google Cloud Workflows docs links to operator and sensor classes (#76667)
- fix: Fix Google Cloud connection IdP extra request parameters being ignored (#76161)
- fix: Fix Grid horizontal scrolling (#76083)
- fix: Fix PgBouncer NetworkPolicy using namespace labels of disabled triggerer KEDA (#74565)
- fix: Fix S3 remote log test for streaming responses (#76632)
- fix: Fix S3ToAzureBlobStorageOperator failing on S3 folder markers (#76408)
- fix: Fix SSHHookAsync deadlock on the extra and compress like SSHHook (#76528)
- fix: Fix SparkConnectHook unsupported-path error message (#74847)
- fix: Fix TimeSensor test failing when host time zone is ahead of UTC (#76901)
- fix: Fix XComArg.map() failing when the upstream XCom is a dict (#75022)
- …and 280 more
Architecture
- Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 0 added · 0 removed
Added bounded contexts (1)
- github.com/apache/airflow/go-sdk
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
apache/airflow 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 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 9e3d1613bda25c58aff3d26864277c5a94237c5b — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.