getredash/redash

Redash is an open-source data visualization and dashboarding platform that enables users to connect to various data sources, write queries, and create interactive visualizations. The system provides a React-based web interface for managing queries, dashboards, alerts, and user permissions, backed by a Python/Flask server that handles data execution via RQ workers. It supports a wide range of database connectors and offers features like parameterized filtering, scheduled query execution, and customizable alert notifications.

36 changes.

This period focused on a comprehensive architectural overhaul, migrating the backend from Celery to RQ and the frontend from AngularJS to React. It involved removing legacy codebases, modernizing the build toolchain with pnpm and Webpack 5, and restructuring the application into modular packages for improved maintainability and security.

58 changes.

This period focused on the comprehensive migration of the frontend from Angular to React, utilizing Ant Design for UI components and restructuring the application's configuration and routing. Concurrently, the backend query execution engine was switched from Celery to RQ, and a robust Cypress-based end-to-end testing infrastructure was established to validate the new interface and core workflows.

28 changes.

The project undertook a comprehensive migration of the client-side interface to React, replacing legacy implementations with modular hooks and reusable components across queries, dashboards, and settings. This period also focused on standardizing the user experience through redesigned navigation, consistent layout components, and enhanced visualization controls. Supporting infrastructure was modernized by migrating CI to GitHub Actions and extracting the visualization library into a standalone package.

The application now includes dedicated CSS for the login page, defining a two-column layout for larger screens (logo on the right, content on the left) and specific styling for the login form elements. Additionally, the Roboto font family (Bold and Light variants) is now bundled as SVG webfonts in the assets directory, ensuring consistent typography for the login interface.

client/app/assets · high confidence

The application now collects performance metrics for HTTP requests and database queries, sending timing data to StatsD. For requests, it tracks the total duration, the number of queries executed, and the cumulative duration of those queries, reporting them per endpoint and HTTP method. For the database layer, it instruments SQLAlchemy to measure the duration of individual SELECT, INSERT, UPDATE, and DELETE operations, reporting the timing per table name and action type. This provides visibility into both API response times and underlying database performance.

redash/metrics · high confidence

The application now includes a new icon font set (redash-icons) containing glyphs for 'flash' and 'flash-off' states. This addition enables UI components to visually represent the state of a flash/toggle feature, supporting the autocomplete toggle improvements mentioned in the commit history.

client/app/redash-font · high confidence

A new hook, useItemsListExtraActions, has been introduced to enable batch selection and action execution on list items. This change adds a checkbox column to item tables, allowing users to select individual or all items on the current page, and provides the necessary state and UI components for extra action buttons to operate on these selections.

client/app/components/items-list/hooks · high confidence

This change introduces the core client application entry point, bootstrapping a React-based UI via \ApplicationArea\ and initializing an offline state listener to provide visual feedback when the network connection is lost. It also establishes the foundational HTML templates (\index.html\, \multi\_org.html\, \unsupported.html\) and configuration files (\.eslintrc.js\, \version.json\) required for the frontend build process.

client/app · high confidence

The repository now includes a dedicated \client/cypress\ directory containing the configuration and automation scripts for end-to-end testing. This adds an ESLint configuration with Cypress-specific rules, a TypeScript configuration for test types, seed data for setting up test environments (including admin setup, login, and data source/destination creation), and a central \cypress.js\ script to manage the test lifecycle (building, starting, seeding, running, and stopping the server via Docker Compose). This enables developers to run full-stack integration tests against the frontend.

client/cypress · high confidence

Adds a new Databricks-specific schema browser component to the query editor, allowing users to browse databases and tables, filter schema items, and select tables for their queries. The feature includes a custom hook for managing schema state, debounced search inputs, and persistent selection of the last used database via local storage.

client/app/components/queries/editor-components/databricks · high confidence

The EmptyState component now displays a guided onboarding flow with a list of actionable steps (such as connecting data sources, creating queries, alerts, dashboards, and inviting users) that track completion status. It supports a closable UI, contextual help messages, and adapts its step content based on user roles (e.g., admins can connect data sources directly, while non-admins are prompted to ask an admin).

client/app/components/empty-state · high confidence

Users can now select predefined dynamic timeframes (such as 'Today', 'This week', 'Last 30 days', or 'Last 10 years') directly within Date and Date Range parameters via a new DynamicButton dropdown. This change adds new components (DateParameter, DateRangeParameter, DynamicDatePicker, DynamicDateRangePicker) that integrate with the existing input fields, allowing users to quickly switch between static dates and relative dynamic ranges without manual entry.

client/app/components/dynamic-parameters · high confidence

The authentication logic has been restructured into a dedicated \redash/authentication\ package, separating concerns for different identity providers. This change introduces distinct modules for Google OAuth, SAML, LDAP, JWT, and remote user authentication, allowing organizations to configure and use these methods independently. It also centralizes core authentication flows, such as API key validation, HMAC signature verification, and user session loading, while adding support for organization-scoped routing and account management features like email verification and password reset tokens.

redash/authentication · high confidence

This change adds support for several new alert notification channels, including Asana, Datadog, Discord, Google Hangouts Chat, Microsoft Teams, and Webex, alongside existing options like Slack, Email, Mattermost, PagerDuty, and generic Webhooks. It also introduces a new \BaseDestination\ class and a registration system in \redash/destinations/\_\init\\_.py\ to standardize how destinations are defined, configured, and invoked, replacing the previous ad-hoc implementation pattern.

redash/destinations · high confidence

A new DefaultPolicy class has been added to the client application to centralize and manage user permissions and feature flags. This service exposes methods to determine if a user can create data sources, destinations, dashboards, alerts, users, and query snippets, as well as retrieving configured refresh intervals. It also provides a mechanism to swap the active policy implementation via a setPolicy function, allowing for flexible permission handling across the application.

client/app/services/policy · high confidence

The query runner subsystem has been restructured with a new base architecture in \_\init\\_.py, introducing explicit column type definitions (integer, float, boolean, string, datetime, date) and a SQL statement splitting utility. This change enables the addition of several new data source connectors, including ArangoDB, Amazon Elasticsearch Service, Axibase Time Series Database, Azure Data Explorer (Kusto), and Amazon Athena, each with their own configuration schemas and type mappings.

_redash/query\runner · high confidence

The Alert Destinations list and edit pages have been rewritten in React. Users can now view, create, edit, and delete alert destinations using the new React-based components, which integrate with the dynamic form system and updated routing infrastructure.

client/app/pages/destinations · high confidence

The Query Snippets management interface has been rewritten in React, replacing the previous implementation. This change introduces a new list view that displays snippets in a sortable table with columns for trigger, description, snippet content, author, and creation date. Users can now create, edit, and delete query snippets via a modal dialog, with access controls enforced based on user roles (administrators or the snippet's creator). The UI includes pagination support and uses the application's standard PlainButton component for interactive elements like the 'Click here' link and trigger names.

client/app/pages/queries-list, client/app/pages/query-snippets · high confidence

The Users list and User Profile pages have been rewritten in React, replacing the previous implementation. This change introduces a new Users List view that separates active users, pending invitations, and disabled users into distinct tabs, and provides a unified User Profile page that dynamically switches between read-only and editable modes based on user permissions. The migration also includes new React hooks for managing user groups and updates to the underlying routing and settings tab registration.

client/app/pages/dashboards, client/app/pages/users · high confidence

A new FavoritesList component has been added to the Home page, displaying two distinct sections for Favorite Dashboards and Favorite Queries. These lists are populated by fetching favorites from the backend, sorted by the 'starred\_at' timestamp in descending order, and presented with links to the respective resources along with an 'Unpublished' label for draft items.

client/app/pages/home/components · high confidence

A new PageHeader component has been introduced to standardize the presentation of titles and action buttons on list pages. This component renders a title and an optional actions area, enabling the addition of new Dashboard, Query, and Alert buttons to their respective list pages as seen in the commit context.

client/app/components/PageHeader · high confidence

The items list interface now uses a new set of React components (EmptyState, ItemsTable, LoadingState, Sidebar) to render list pages. This introduces a standardized empty-state message ('Sorry, we couldn't find anything.'), a dedicated loading state using a spinner, and a sidebar with search, menu, and tag filtering capabilities. The ItemsTable component provides a structured way to define columns (including favorites, avatars, dates, and time-ago formats) and handles sorting and row selection, replacing the previous implementation.

client/app/components/items-list/components · high confidence

The authentication settings page now uses dedicated components for managing password login, Google login, and SAML configuration. Password login can be disabled only if another method (Google, LDAP, or SAML) is enabled, with a warning shown if it is the only option. Google login allows restricting access to specific Google Apps domains. SAML supports both static configuration (SSO URL, Entity ID, certificate) and dynamic configuration (Metadata URL, Entity ID, NameID format).

client/app/pages/settings/components/AuthSettings · high confidence

A new Paginator class has been added to the client application to handle data pagination and sorting logic. This utility allows users to slice data arrays into specific pages based on a page number and items-per-page setting, and supports sorting rows by a specified column in ascending or descending order. The implementation relies on lodash's sortBy function for the sorting mechanism.

client/app/lib/pagination · high confidence

Added five new hooks to the client library to standardize recurring UI logic: useFullscreenHandler manages fullscreen mode via URL search parameters and body classes; useImmutableCallback ensures stable callback references for dependency arrays; useLazyRef defers initial value computation for refs; useSearchResults provides debounced, cancellation-safe search fetching with loading states; and useUniqueId generates stable unique IDs with a prefix using lazy initialization.

client/app/lib/hooks · high confidence

This change introduces new React components for the dashboard experience: a sticky DashboardHeader that displays the title, tags, user avatar, and controls for editing, forking, archiving, and auto-refreshing; DashboardListEmptyState which provides context-specific messages for empty dashboard lists (e.g., favorites, my dashboards); and ShareDashboardDialog which allows users to toggle public access and view the secret URL, with a security warning for dashboards containing text parameters.

client/app/pages/dashboards/components · high confidence

This change introduces a comprehensive set of new HTML and text email templates for Redash, including layouts for alerts, query failure reports, user invitations, password resets (including disabled account notifications), and email verification. Users will now receive these newly styled and structured emails for system notifications and account actions, replacing or supplementing previous email formats.

redash/templates/emails · high confidence

Added a new PasswordForm component to the user profile page that provides distinct actions based on the current user's role and the target user's status. For the logged-in user, a 'Change Password' button opens a dialog to update credentials with client-side validation. For administrators managing other users, the form conditionally displays either a 'Resend Invitation' button (if the user is pending) or a 'Send Password Reset Email' button, both of which handle server-side requests and display the resulting reset link via a shared alert component when email delivery fails.

client/app/pages/users/components/PasswordForm · high confidence

This change introduces several new helper modules in the client library to support the ongoing frontend migration. It adds an accessibility utility for screen-reader notifications, a text-width calculator for layout precision, a local storage wrapper for user preferences, and a query formatter that supports SQL and JSON syntax. Additionally, it provides a React hook for memoized query result data extraction and a suite of utility functions for date/time formatting, duration humanization, and number/size pretty-printing.

client/app/lib · high confidence

This change introduces the foundational utility modules for the Redash application, including JSON serialization with custom encoders for SQLAlchemy queries and special types, CSV writing with configurable encoding and error handling, and Mustache templating. It adds a ConfigurationContainer class for validating and managing data source settings with JSON Schema, and initializes Sentry integration for error tracking and performance tracing with specific integrations for Flask, Redis, RQ, and SQLAlchemy. The update also includes query ordering utilities, human-readable time parsing, and a configured HTTP session that respects settings for redirect allowance and private address blocking.

redash/utils · high confidence

This entry covers the v26.03.0 release of Redash. Key updates include upgrading the Python runtime to version 3.13 and migrating the frontend build toolchain from Yarn to pnpm. The release also introduces a pivot chart visualization, adds a range slider to charts, and enhances dashboard parameter handling to persist and apply saved values. Additional features include support for IPv6 in Kubernetes clusters, new date range options (last 2/3/10 years), and improved data source support for DuckDB, DB2, and Trino (including impersonation). Several fixes address chart rendering issues, PostgreSQL password handling, and alert evaluation stability.

(repo-wide) · high confidence

The visualization components previously embedded in the main Redash codebase are now available as a standalone npm package (@redash/viz). This library, initialized at version 0.1.0, allows external applications to integrate Redash visualizations (such as Charts, Tables, Maps, and Pivots) using React and Antd. It provides public APIs including \Renderer\ and \Editor\ components, supports configuration via \updateVisualizationsSettings\, and is built with TypeScript and Webpack 5 for distribution.

viz-lib · high confidence

The visualization editor's user interface components—including the ColorPicker, TextAlignmentSelect, JsonViewInteractive, SortableContainer, and various editor controls (Switch, TextArea, Section, ContextHelp)—have been rewritten in TypeScript. This migration introduces stricter type safety and improved developer experience for the configuration panels used to customize chart and table visualizations.

viz-lib/src · high confidence

The legacy \rd\_ui/app\ directory, which served as the root for the original AngularJS-based web interface, has been completely removed. This deletion eliminates the old HTML templates (including the main \index.html\ layout and the \404.html\ error page), the CoffeeScript build ignore rules, and the associated client-side dependencies (such as Highcharts, jQuery, and AngularJS libraries) that were previously loaded via Bower. Users will no longer interact with this deprecated frontend layer.

_rd\ui/app · high confidence

The legacy AngularJS-based user interface components for dashboards, queries, and administration have been removed from the application. This change deletes the view templates for the main dashboard layout, query editor (QueryFiddle), query list, admin status page, and associated modal dialogs for editing dashboards and adding widgets. These files are no longer part of the rendered UI, indicating a migration away from this frontend codebase.

_rd\ui/app/views · high confidence

The \rd\_ui/app/styles/redash.css\ file has been deleted, removing legacy CSS rules for the main body padding, navbar branding, graph containers, avatar spacing, and in-place editing components. The diff also removes styles associated with the \angular-growl\ notification library and the \Gridster\ dashboard widget layout system, as well as specific styling for the CodeMirror editor (which the commit history indicates was replaced by the Ace editor). This cleanup eliminates unused styles from the codebase.

_rd\ui/app/styles · high confidence

The application has removed several legacy JavaScript files and dependencies, including the admin status controller, the main app module configuration, core controllers (Dashboard, QueryFiddle, Queries), directives (tabs, dashboard editing, widget forms, edit-in-place), filters, the Highcharts wrapper, services, the smart-table library, and the Angular UI Bootstrap library. This cleanup eliminates unused code and external libraries from the rd\_ui/app/scripts directory, likely as part of a broader migration to a new UI architecture.

_rd\ui/app/scripts · high confidence

The legacy \Dashboard\ and \notifications\ services in the \rd\_ui\ application have been removed. This cleanup eliminates the old AngularJS-based logic for dashboard editing permissions and HTML5 desktop notifications, which has already been migrated to the frontend.

_rd\ui/app/scripts/services · high confidence

The \rd\_service/data\ module has been completely removed, deleting the legacy \Manager\, \Worker\, and \Job\ classes, along with \models.py\, \query\_runner.py\, \tables.sql\, and \utils.py\. This eliminates the previous threading-based connection pooling and synchronous job execution logic, indicating a shift to a different architecture for handling database connections and query processing.

_rd\service/data · high confidence

The \renderers.js\ file containing the \chartRenderer\, \gridRenderer\, and \pivotTableRenderer\ directives has been deleted from the \query\_fiddle\ module. This removes the legacy implementations for rendering query results as charts, grids, and pivot tables within the query fiddle interface.

_rd\_ui/app/scripts/query\fiddle · high confidence

The rd\_service directory has been removed, deleting the legacy Python backend files including the CLI entry point, server handlers (such as authentication, query management, and dashboard widgets), and configuration examples. This eliminates the old Tornado-based server implementation and its associated command-line worker processes from the codebase.

_rd\service · high confidence

The application's configuration system has been refactored from a single monolithic file into a structured package (\redash/settings\). This change introduces dedicated modules for organization-specific settings (such as date/time formats, number separators, and authentication flags like SAML/JWT/LDAP), helper utilities for parsing environment variables, and a new \dynamic\_settings.py\ module that allows administrators to override query time limits, define custom SSH tunnel authentication, and specify custom database primary/foreign key types. Existing environment variables are preserved, but the internal wiring is now split across these new files to improve maintainability and support dynamic configuration overrides.

redash/settings · high confidence

The application's backend request handlers have been reorganized from a single monolithic module into a structured \redash.handlers\ package. This change introduces dedicated modules for specific domains—such as \authentication\, \alerts\, \dashboards\, \data\sources\, \databricks\, \destinations\, and \embeds\—alongside a shared \base\ module for common utilities like pagination and event recording. The \api.py\ module now centrally registers all API resources, and the new \\\init\\_.py\ initializes the application by registering these blueprints, improving code maintainability and separation of concerns without altering the external API surface.

redash/handlers · high confidence

The admin section's user interface has been rewritten in React, introducing new components for layout, status display, and job monitoring. The new Layout.jsx provides a horizontal navigation menu for System Status, RQ Status, and Outdated Queries. RQStatus.jsx implements tables for viewing workers, queues, and query jobs with pagination and status badges. StatusBlock.jsx renders cards for general system info, database metrics, and manager details. This change replaces the previous implementation with a modern React-based structure using Ant Design components.

client/app/components/admin · high confidence

The Admin section now uses React components for the Jobs, Outdated Queries, and System Status pages. The Jobs page displays real-time RQ (Redis Queue) status, including counters for started and queued jobs, and tabs for Queues, Workers, Queries, and Other Jobs, with data auto-refreshing every 60 seconds. The Outdated Queries page lists queries that need updating, supporting auto-refresh and pagination. The System Status page aggregates general system info, manager metrics, queue details, and database metrics, also refreshing periodically. All pages use the new admin Layout and register their own routes.

client/app/pages/admin · high confidence

The alert creation, editing, viewing, and management interface has been rewritten in React, replacing the previous implementation. This change introduces a redesigned user experience for the alert page, including new components for configuring alert criteria, notification templates, and query selection, as well as improved state management for alert status and permissions.

client/app/pages/alert · high confidence

The alert configuration interface has been completely rewritten in React, replacing the previous implementation. This migration introduces new components for managing alert destinations (AlertDestinations), defining evaluation criteria with min/max/first selectors (Criteria), configuring notification templates with custom subject/body support (NotificationTemplate), and setting rearm intervals (Rearm). The UI now uses Ant Design v4 components, includes a dedicated menu button for alert actions (mute, delete, evaluate), and provides a redesigned layout for query selection and alert title editing. The change also adds support for custom alert notification templates using Mustache, allowing users to define custom subject and body text with preview capabilities.

client/app/pages/alert/components · high confidence

The Alerts list page has been rewritten in React, replacing the previous implementation. This change introduces a modern UI with sortable columns for alert status, name, creator, state, and timestamps, along with pagination and an empty state help message. The page now uses the new Link component for navigation and integrates with the ItemsList framework for data fetching and state management, while respecting user permissions to show the 'New Alert' button.

client/app/pages/alerts · high confidence

The CardsList component has been rewritten in TypeScript and updated to use a new 'visual-card' layout. This change introduces a styled card interface with hover and focus effects, responsive sizing for various screen widths, and an optional search filter. The component now handles items with either an href or an onClick handler, rendering them as links or buttons respectively.

client/app/components/cards-list · high confidence

The application's initialization process has been consolidated into a new \client/app/config/index.js\ entry point. This change introduces a standardized setup flow that registers visualizations, loads page routes, configures internationalization time strings via Moment.js, and dynamically loads frontend extensions. Additionally, it establishes a global Ant Design spinner indicator for consistent loading states and ensures all image assets are properly bundled and available.

client/app/config · high confidence

The Data Sources list and edit pages have been rewritten in React, replacing the previous implementation. Users can now view, create, edit, and delete data sources through the new React-based components, which utilize the DynamicForm for configuration and integrate with the updated routing system.

client/app/pages/data-sources · high confidence

This update applies a series of database migrations to improve data integrity and performance. Key changes include migrating JSON columns to the more efficient JSONB type across tables like queries, dashboards, and widgets, and re-indexing the full-text search vector for queries. The schema also introduces a 12-column grid layout for dashboards (scaling existing widget positions), adds a default alert selector, and consolidates user profile image URLs into a JSON details column. Additionally, query hash generation is updated to be case-insensitive and aware of query parameters, and data source options are encrypted for security.

migrations/versions · high confidence

The query editing interface now uses a collection of dedicated React hooks (located in \client/app/pages/queries/hooks\) to manage specific behaviors, replacing previous inline implementations. These hooks encapsulate logic for query execution and state (\useQueryExecute\, \useQuery\), parameter management (\useQueryParameters\, \useAddNewParameterDialog\), visualization handling (\useAddVisualizationDialog\, \useEditVisualizationDialog\, \useDeleteVisualization\), and query lifecycle actions like saving, archiving, forking, and scheduling. This change centralizes the complex state and side-effect management required for the query editor into modular, reusable components.

client/app/pages/queries/hooks · high confidence

The Home page has been rewritten as a React component, replacing the previous implementation. This change introduces a new layout that displays alerts for deprecated embed features and unverified email addresses, utilizes a DynamicComponent system for the main empty state and extra content, and includes a favorites list for dashboards and queries. The page is now registered via a dedicated route definition within the React application structure.

client/app/pages/home · high confidence

The \bin/docker-entrypoint\ script now serves as the primary container entrypoint, replacing previous Celery-based workflows with RQ (Redis Queue) for worker and scheduler tasks. It supports multiple modes including production server (with configurable gunicorn settings like bind address, timeout, and worker recycling), RQ workers with healthchecks, and development modes with auto-reload. The entrypoint also handles database creation, test execution, and shell access. Additionally, new Python scripts \bin/get\_changes.py\ and \bin/release\_manager.py\ provide automated release management capabilities, including GitHub release creation, asset uploading, and changelog generation using simplejson for consistent JSON handling.

bin · high confidence

The application now uses a dedicated serializers module to handle data conversion for API responses, replacing ad-hoc \to\_dict\ methods. This change centralizes how queries, visualizations, widgets, and dashboards are serialized, ensuring consistent field inclusion (such as favorite state and user details) and improving separation of concerns. It also introduces robust serialization for query results, including correct handling of boolean and date/time values in CSV/TSV exports and proper formatting for XLSX downloads, while restricting sensitive query information in public dashboard views.

redash/serializers · high confidence

The parameter service layer has been refactored to use a class-based inheritance structure, introducing a base Parameter class and specific subclasses (DateParameter, DateRangeParameter, EnumParameter, NumberParameter, TextParameter, TextPatternParameter, and QueryBasedDropdownParameter) to handle type-specific normalization, URL serialization, and execution value generation. This change adds a new TextPattern parameter type that validates input against a regular expression, and significantly expands the DateRangeParameter with a comprehensive set of dynamic presets including 'Last 12 months', 'Last 2 years', 'Last 3 years', and 'Last 10 years' (in addition to existing options like 'Today', 'Yesterday', and 'Last 7 days'). The refactoring also ensures consistent handling of multi-value options for Enum and Query-based dropdowns and standardizes how parameters persist and apply saved values across the dashboard.

client/app/services/parameters · high confidence

This change adds a suite of React hooks in the dashboard page area to centralize and improve dashboard interaction logic. The new \useDashboard\ hook consolidates core state management, including handling parameter persistence, widget loading with error catching, and dashboard updates. \useEditModeHandler\ introduces a debounced layout saving mechanism with explicit status tracking (saved, saving, failed) to prevent race conditions when exiting edit mode. \useDuplicateDashboard\ enables forking a dashboard into a new browser tab while preserving current URL parameters. \useRefreshRateHandler\ manages automatic dashboard refreshing based on URL parameters, enforcing policy-defined minimum intervals. \useDataSources\ provides a clean interface for loading available data sources.

client/app/pages/dashboards/hooks · high confidence

The query editor now supports distinct UI components for different data sources. A new registry system allows registering specific implementations (such as a Databricks Schema Browser) that override the default components for targeted data source types like 'databricks' and 'databricks\_internal', while falling back to the standard SchemaBrowser and QueryEditor for other sources.

client/app/components/queries/editor-components · high confidence

The ItemsList component in the client app now wraps the search update function with a debounce mechanism (200ms) and a concurrency guard. This ensures that rapid search inputs do not trigger multiple simultaneous API requests; instead, only the most recent search term is processed, improving performance and reducing server load during fast typing.

client/app/components/items-list · high confidence

The CI pipeline has been migrated from CircleCI to GitHub Actions, introducing new Docker Compose configurations for both general CI runs and Cypress end-to-end testing. The test environment now utilizes PostgreSQL 18 and Redis 7, while the Cypress runner is built on a Node 24 base image using pnpm for dependency management. Additionally, the release process has been updated to automatically build and push preview Docker images to Docker Hub for the main repository's master and preview-image branches, and version strings are now dynamically generated using GitHub run identifiers.

.ci · high confidence

The DynamicForm component and its supporting field types (Input, Select, Checkbox, File, AceEditor, etc.) have been rewritten in React, replacing the previous Angular implementation. This migration introduces new behaviors for handling form data, including normalizing empty values to null on submission, correctly applying default values to checkboxes, and managing the visibility of extra fields via a prop. The component now leverages Ant Design's Form API for validation and state management, ensuring consistent styling and interaction patterns across the application.

client/app/components/dynamic-form · high confidence

The Groups List, Group Members, and Group Data Sources pages have been rewritten in React, replacing the previous implementation. This change introduces a consistent UI using Ant Design components (such as Buttons, Dropdowns, and Menus) and leverages the shared ItemsList, Paginator, and PreviewCard components for table rendering and pagination. Administrators can now manage group members and data sources through these new React-based interfaces, which include features like adding/removing members and data sources, setting data source permissions (Full Access vs. View Only), and deleting groups, all integrated with the new routing and settings tab system.

client/app/pages/groups · high confidence

The Group List and Details pages have been migrated from the previous framework to React. This change introduces new React components for managing groups, including CreateGroupDialog for adding new groups, DeleteGroupButton for safe deletion with confirmation, DetailsPageSidebar for group actions (adding members/data sources, deleting), GroupName for inline editing of group names, and ListItemAddon for visual indicators in list items. The migration also updates the underlying service layer to use axios instead of $http and improves accessibility for input fields and icons.

client/app/components/groups · high confidence

The Organization Settings page has been rewritten in React, replacing the previous implementation. This change introduces a new \OrganizationSettings\ component that uses the \useOrganizationSettings\ hook to manage state, fetch data via \OrgSettings.get()\, and save changes via \OrgSettings.save()\. The UI now utilizes Ant Design components (Form, Button, Skeleton) for a consistent look and feel, including loading states. The settings are registered as a new route at \/settings/general\ with admin permissions, and saving updates the client configuration for date and time formats.

client/app/pages/settings · high confidence

The Query Source and Query View pages have been rewritten in React, replacing the previous implementation. This change introduces a new component structure with dedicated hooks for managing query execution, data sources, parameters, and visualizations, along with updated styling for the query editor and results layout.

client/app/pages/queries · high confidence

The \client/app/components\ directory has been migrated from Angular to React, introducing a suite of new React components (such as \AceEditorInput\, \BeaconConsent\, \BigMessage\, \CodeBlock\, \Collapse\, \CreateSourceDialog\, \DateInput\, \DialogWrapper\, \DynamicComponent\, \EditInPlace\, \EditParameterSettingsDialog\, \EmailSettingsWarning\, \FavoritesControl\, \Filters\, \HelpTrigger\, and \InputWithCopy\) that replace the previous Angular implementations. This change updates the user interface to use Ant Design components for dialogs, forms, and inputs, and introduces new capabilities like a beacon consent prompt for anonymous usage data, a unified dialog wrapper system, and improved parameter editing workflows.

client/app/components · high confidence

The client application services in \client/app/services\ have been rewritten from Angular-style dependencies to a modern React-compatible architecture. HTTP communication now uses Axios instead of the legacy \$http\ service, featuring automatic CSRF token handling and session refresh interceptors. Security is improved by replacing \angular-sanitize\ with DOMPurify, which now explicitly allows the \target\ attribute on links while adding \rel="noopener noreferrer"\ to prevent reverse tabnabbing. The codebase also introduces a new \KeyboardShortcuts\ service for global key bindings, a \Location\ service for URL management, and a \Notification\ service wrapping Ant Design components, while adding unit tests for the authentication and query result logic.

client/app/services · high confidence

The dashboard editing experience has been rebuilt using React, replacing the previous Angular-based implementation. This change introduces new React components for core dashboard interactions, including the Add Widget dialog (featuring query and visualization selection with parameter mapping), the Create Dashboard dialog, the Textbox editor (with live Markdown preview), and the Parameter Mappings editor. The dashboard grid itself is now a React component powered by react-grid-layout, supporting responsive layouts, widget resizing, and an AutoHeightController for dynamic widget sizing. These updates provide a more consistent UI, improved performance through React's rendering model, and better maintainability for future dashboard features.

client/app/components/dashboards · high confidence

The dashboard widget components (VisualizationWidget, TextboxWidget, RestrictedWidget, and the base Widget wrapper) have been rewritten in React. This migration introduces a consistent component structure with dedicated header and footer sections, supports editing text boxes via a modal dialog, and provides visualization widgets with parameter handling, query viewing, and download options (CSV, TSV, Excel). The new implementation also includes a restricted widget state for data sources without access and improves accessibility with proper ARIA labels and focus styles.

client/app/components/dashboards/dashboard-widget · high confidence

The project has switched its database migration tooling from the previous system to Alembic (via Flask-Migrate). This introduces a new \migrations/\ directory containing the standard Alembic configuration (\alembic.ini\), environment setup (\env.py\), and migration script templates (\script.py.mako\). Additionally, a warning script (\0001\_warning.py\) has been added to alert users who attempt to use the outdated Fabric upgrade script, ensuring they adopt the new migration process.

migrations · high confidence

The query execution engine has been replaced with the RQ (Redis Queue) library, moving away from the previous Celery-based implementation. This change introduces new task structures in \redash/tasks/queries/execution.py\ for enqueuing and running queries, and \redash/tasks/queries/maintenance.py\ for background jobs like schema refreshes and result cleanup. Users will experience query execution and scheduling handled by RQ, which includes specific behaviors for job locking, timeout management, and status tracking via Redis.

redash/tasks/queries · high confidence

The Add to Dashboard, Embed Query, and Schedule dialogs in the queries area have been rewritten from their previous implementations into React components. This migration introduces a consistent dialog wrapper pattern, integrates Ant Design v4 UI primitives (such as Modal, Select, and DatePicker), and adds specific capabilities like UTC time display in the Schedule dialog, configurable iframe sizing in the Embed dialog, and dashboard search functionality in the Add to Dashboard dialog.

client/app/components/queries · high confidence

The tags control UI has been rewritten in React, introducing the \TagsControl\ component for displaying tags and the \EditTagsDialog\ for managing them. This change adds a new 'Add tag' button when no tags are present, improves accessibility by using \PlainButton\ and screen-reader-only text for the edit action, and ensures the tag selection input receives focus once available tags are loaded. It also introduces specific variants (\QueryTagsControl\ and \DashboardTagsControl\) that display 'Unpublished' or 'Archived' status labels with appropriate tooltips.

client/app/components/tags-control · high confidence

Redash replaces the Celery task queue with RQ (Redis Queue) for handling background jobs. This change introduces a new task infrastructure in \redash/tasks\, including custom RQ worker and queue classes that enforce hard time limits to prevent stuck jobs, integrate with Statsd for metrics, and support job cancellation. The migration updates core scheduled tasks—such as query execution, alert checking, schema refreshing, and failure reporting—to use RQ decorators and scheduling mechanisms, ensuring consistent timeout enforcement and improved reliability for background operations.

redash/tasks · high confidence

The signed-out page layout has been refactored to be more modular by introducing new include files (signed\_out\_tail.html and tail.html). This change allows frontend elements to be overridden via extension points, enabling custom themes or integrations to inject content into the signed-out view without modifying core templates.

_redash/templates/\includes · medium confidence

The General Settings page now includes dedicated sections for Date/Time formatting (synced with client configuration), number formatting (customizable thousands and decimal separators), Plotly chart visualization options, and Feature Flags (including experimental multiple owners support, email notifications for failed scheduled queries, and multi-byte search). It also reintroduces a Beacon Consent setting for anonymous usage data sharing, all wrapped in a DynamicComponent architecture for extensibility.

client/app/pages/settings/components/GeneralSettings · high confidence

This change introduces three new React components within the EditVisualizationButton directory: QueryControlDropdown, QueryResultsLink, and EditVisualizationButton. The QueryControlDropdown provides a menu for users to add queries to dashboards, embed results elsewhere (subject to public URL settings), and download query results in CSV, TSV, or Excel formats via the new QueryResultsLink component. The EditVisualizationButton component renders a button to open the visualization editor. These components replace previous implementations, leveraging Ant Design for UI elements and a custom Link component for file downloads.

client/app/components/EditVisualizationButton · high confidence

The ApplicationArea now uses a new React-based Router component that manages client-side navigation using UniversalRouter, replacing the previous implementation. This change introduces a dedicated ErrorMessage component to display user-friendly messages for HTTP errors (such as 404 and 401/403) and unhandled JavaScript errors, ensuring a consistent error experience. The routing logic now supports dynamic route registration and includes a handleNavigationIntent utility to intercept standard link clicks for single-page application navigation. Additionally, route wrappers like routeWithUserSession and routeWithApiKeySession have been updated to integrate with this new router structure, providing session management and error boundary context to route components.

client/app/components/ApplicationArea · high confidence

A new \ContentWithSidebar\ layout component and its associated styles have been added to the application. This component structures pages with a 25% width sidebar on the left and a 75% width content area on the right, switching to a stacked vertical layout on screens narrower than 990px. This change supports the reorganization of list pages by moving the sidebar to the left side of the content area.

client/app/components/layouts · high confidence

A new styling class and corresponding TypeScript helper functions have been added to support horizontal forms with left-aligned labels. The \.ant-form-horizontal--labels-left\ class ensures labels are left-aligned and removes the default colon suffix, while the \getHorizontalFormProps\ and \getHorizontalFormItemWithoutLabelProps\ functions provide pre-configured Ant Design form props to apply this layout consistently.

client/app/styles · high confidence

A new layout template for the signed-out state has been added to the application. This template defines the structure for pages displayed when a user is not authenticated, including the HTML head with viewport and compatibility meta tags, links to the main stylesheet and favicons, and a body structure that centers content. It includes a header section with the Redash logo and an optional title, a content block for page-specific content, and a scripts block for footer assets, ensuring a consistent look and feel for sign-out related pages.

redash/templates/layouts · high confidence

This release initializes the Redash application structure for version 26.09.0-dev, establishing the core Flask app creation, security configuration (CSRF, HTTPS enforcement via Flask-Talisman), and permission system. It introduces a new monitoring module that exposes Redis status, database sizes, and RQ worker/queue metrics, while also implementing a background version check that reports usage data to Redash if beacon consent is enabled. The worker infrastructure is updated to use RQ with StatsD recording for job metrics.

redash · high confidence

The User model now stores identity details (profile image, invitation status, email verification) and the last-active timestamp within a single JSONB 'details' column, replacing previous separate fields. User activity is tracked via Redis and periodically synced to the database, allowing admins to distinguish between active and pending users in the user list. Additionally, the User model now supports regenerating API keys, and profile image URLs are handled with a fallback to a default avatar for disabled users.

redash/models · high confidence

The Query Editor component has been refactored to include a new control bar featuring an 'Auto Limit' checkbox that restricts query results to the first 1,000 rows, and a toggle for enabling or disabling live autocomplete. The editor now supports schema-aware autocompletion for tables and columns, and includes improved keyboard shortcut handling and accessibility notifications for screen readers.

client/app/components/queries/QueryEditor · high confidence

The login, invite, password reset, forgot password, email verification, and initial setup screens have been redesigned with a new tiled UI layout. These pages now support multiple SSO providers (Google, SAML, Remote User, LDAP) with dedicated login buttons on the login and invite pages, and all forms include CSRF protection. The setup wizard now includes options to subscribe to security notifications and a newsletter.

redash/templates · high confidence

The application now features a completely redesigned navigation system. On desktop, the sidebar has been replaced with a vertical, icon-based navbar that highlights the active section and includes a 'Create' menu for dashboards, queries, and alerts based on user permissions. On mobile devices, a fixed top header bar with a hamburger menu provides access to the same navigation items, profile settings, and logout options. The layout also includes a new VersionInfo component in the profile menu to display the current version and update availability for administrators, and the overall structure now properly handles headless mode by hiding navigation elements.

client/app/components/ApplicationArea/ApplicationLayout · high confidence

The query page interface has been redesigned to improve usability and visual consistency. A new header component now manages the query title, tags, and action menu (including publish, archive, and fork options) with improved mobile responsiveness. Execution status and metadata are now displayed in dedicated components that clearly show row counts, runtime, data scanned, and truncation warnings, while providing a prominent cancel button during processing. Visualization management has been enhanced with a tabbed interface that supports adding, deleting, and switching between multiple visualizations, and preserves filter selections across tabs. Additionally, new alert components guide users when no data sources are available or when they lack permissions to create queries.

client/app/pages/queries/components · high confidence

The Redash management script has been rewritten to use the Click library instead of the previous Flask-script manager, providing a more robust and consistent command-line interface. The CLI is now organized into distinct subcommands for managing users, groups, data sources, organizations, queries, and RQ workers, allowing administrators to perform operations like creating root users, managing data source connections, and monitoring worker health directly from the terminal.

redash/cli · high confidence

The User Profile page has been refactored into distinct components (EditableUserProfile, ReadOnlyUserProfile, UserInfoForm, ApiKeyForm, PasswordForm, ToggleUserForm) to improve modularity. A key behavioral change is that user group information is now fetched via a dedicated hook (useUserGroups) rather than being passed directly or managed in useEffect, ensuring the Groups field in the user info form and the read-only view loads asynchronously. The CreateUserDialog has also been updated to align with Ant Design v4 standards, and extension points (DynamicComponent) have been added to allow for future customization of the profile forms.

client/app/pages/users/components · high confidence

The ItemsList component's underlying data-fetching logic has been restructured into a set of dedicated classes (ItemsFetcher, ItemsSource, Paginator, Sorter, StateStorage). This change introduces a more modular approach to handling list data, supporting both client-side sorting/pagination for plain lists and server-side pagination for paginated lists. It also adds URL state synchronization, allowing search terms, sorting, and pagination state to be reflected in the browser's URL bar, improving shareability and browser history support for list views.

client/app/components/items-list/classes · high confidence

The rd\_ui directory has removed its legacy build and dependency management files, including Gruntfile.js, bower.json, .bowerrc, and associated test configurations (karma.conf.js, karma-e2e.conf.js). This change eliminates the Bower-managed frontend dependency tree (Angular, Bootstrap, Highcharts, etc.) and the Grunt-based asset compilation pipeline, indicating a migration away from this specific build stack.

_rd\ui · high confidence

The bundled CA certificates used for verifying SSL connections to Amazon RDS and Redshift have been updated. The new \rds-combined-ca-bundle.pem\ includes recent Amazon RDS root and regional CAs (such as af-south-1, eu-south-1, and me-south-1), ensuring continued trust for newer RDS instances. Additionally, the \redshift-ca-bundle.crt\ has been refreshed to include the latest Amazon Root CAs (1-4) and Starfield certificates, resolving potential SSL handshake failures for Redshift connections that rely on these updated trust anchors.

_redash/query\runner/files · high confidence

The visualization editing experience has been restructured to improve stability and configurability. A new EditVisualizationDialog component now manages the editor state, utilizing memoized query result data to prevent unnecessary re-renders and ensuring that selected filters are preserved when switching between visualizations. The underlying renderer and editor components are now wrapped to inject global client configuration, such as date/number formatting and custom map data for Choropleth charts, directly into the visualization library. Additionally, the renderer now correctly combines local and global filters, ensuring that filter selections persist and update correctly as query results or global filter contexts change.

client/app/components/visualizations · high confidence

A placeholder file has been added to the client/app/extensions directory to ensure it is tracked by version control. This change resolves a build failure where the webpack configuration could not locate the extensions directory during the build process.

client/app/extensions · high confidence

Added Cypress integration tests for alert creation, editing, and viewing; Added Cypress integration tests for data source and group management pages; Added Cypress integration tests for organization settings and user-specific navigation; Added Cypress support utilities for chart and table visualization testing; Added Cypress test for creating query snippets with empty descriptions; Added Cypress tests for embed sharing and parameter safety; Added Cypress tests for the Create Destination page; Added end-to-end tests for query creation, filtering, parameters, and tagging; Added end-to-end tests for user authentication and management; Added end-to-end tests for visualizations; Added model unit tests for alerts, queries, and data sources; Added snapshot test for ReadOnlyUserProfile component; Added snapshot tests for the ScheduleDialog component; Added test environment setup for visualization library; Added test infrastructure for Enzyme and date mocking; Added tests for JSON serialization sanitization; Added tests for query result and DSV serialization; Added tests for task execution, scheduling, and metrics; Added tests for unicode handling in webhook notifications; Added unit tests for query runner components; Added visual regression tests for the Table visualization; Comprehensive end-to-end test suite for dashboard features; Initial test coverage for backend API handlers; Initial test suite infrastructure and coverage; New Cypress API helper library for end-to-end testing; New Cypress support utilities for dashboard interactions; New Cypress support utilities for tag interactions; New Cypress test utilities for authentication, UI interaction, and parameter handling; Removed legacy test infrastructure files.

The frontend build system has switched from npm to pnpm (v10.30.3) and upgraded the Node.js requirement to version 18 or higher. This change includes a major upgrade of the build toolchain, moving from Webpack 4 to Webpack 5 and updating Babel to version 7.29.0. The \viz-lib\ package has been converted to TypeScript and now uses its own \package.json\ with specific peer dependencies for React 16.14.0 and Ant Design 4. Additionally, legacy build artifacts such as \rd\_ui/package.json\ (Grunt-based) and \rd\_service/requirements.txt\ have been removed.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 46.

• Code Health 68
• Architecture 47
• Maturity 54
• Readiness 39
• Security 62
• Accessibility 52

• 300 commits — 245 feature/other, 55 fixes

• (root) — 125 commits
• redash/query_runner — 51 commits
• client/app — 32 commits
• viz-lib/src — 24 commits
• .github/workflows — 19 commits
• redash/models — 8 commits
• migrations/versions — 5 commits
• redash/tasks — 5 commits
• bin/docker-entrypoint — 4 commits
• viz-lib/yarn.lock — 4 commits
• redash/authentication — 3 commits
• redash/destinations — 3 commits
• redash/security.py — 3 commits
• redash/utils — 3 commits
• client/cypress — 2 commits
• redash/handlers — 2 commits
• viz-lib/package.json — 2 commits
• redash/cli — 1 commit
• redash/monitor.py — 1 commit
• redash/serializers — 1 commit

• fix: Adding ability to fix table columns in place (#7019)
• fix: Bump elliptic to version 6.5.7 to fix a Dependabot warning (#7120)
• fix: ClickHouse query runner: fixed error message (#6764)
• fix: FIX : redash docker image TAG (#7280)
• fix: Fix 'str' object has no attribute 'pop' error when parsing query (#6941)
• fix: Fix [CVE redacted]: upgrade form-data to patched version (#7717)
• fix: Fix Elasticsearch connector configuration key mismatch (#7607)
• fix: Fix RQ wrongly moving jobs to FailedJobRegistry (#7186)
• fix: Fix UnboundLocalError when checking alerts for query (#7346)
• fix: Fix a display order bug in MongoDB Query Runner (#7106)
• fix: Fix alert evaluation logic and issue with calculating min and max of columns without numbers (#7103)
• fix: Fix columns duplication on MongoDB Query Runner #6640 (#6641)
• fix: Fix css height for mobile safari not to overlap URL bar (#7334)
• fix: Fix display of "Name" values for X and Y axes (#7701)
• fix: Fix error in rehash DB migration with Elasticsearch queries (#7292)
• fix: Fix error on pnpm install (#7670)
• fix: Fix errors in webex alert destination. Add formatting support for QUERY_RESULT_TABLE. (#7296)
• fix: Fix issue with scheduled queries (#7111)
• fix: Fix mismatched poetry version (#7122)
• fix: Fix regular expression warning (#7650)
• …and 280 more

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

getredash/redash 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.