Grafana: Open Source Observability Dashboards

What Grafana is

Grafana describes itself as "the open-source platform for monitoring and observability". Its README puts the job plainly: Grafana lets you query, visualize, alert on and understand your metrics no matter where they are stored, and create, explore and share dashboards with your team. The documentation widens that to metrics, logs and traces, and says the open source edition turns time-series database (TSDB) data into graphs and visualizations while its plugin framework connects other sources such as NoSQL and SQL databases, ticketing tools like Jira or ServiceNow, and CI/CD tooling like GitLab.

The important design point is that Grafana is not a database. It does not store your metrics or logs; it connects to the systems that already hold them, such as Prometheus, Loki, Elasticsearch, InfluxDB, PostgreSQL or a cloud monitoring service, and queries them on demand. The data source documentation defines a data source as "a connection to a storage backend that holds your data", which Grafana queries to retrieve metrics, logs, traces and profiles that it then visualizes in dashboards and Explore. Grafana keeps only its own configuration, users and dashboards in a small database of its own.

The audience ranges from someone charting smart-home data, an example the introduction gives, to administrators running Grafana for many teams. The documentation's FAQ lists infrastructure and application monitoring, observability and operational dashboards as the main uses.

Grafana Labs ships the same core in three editions: Grafana OSS, the free, self-managed open source edition; Grafana Enterprise, a self-managed commercial edition with extra features, plugins and support; and Grafana Cloud, a fully managed service with a free tier. This write-up focuses on the open source repository, with notes on where the editions differ.

How it works

A Go backend and a TypeScript frontend

The developer guide says Grafana consists of two components, a frontend and a backend. The backend is Go: make run "compiles the Go source code and starts a web server", by default on http://localhost:3000/. The frontend is a TypeScript and React application built with pnpm and served by an rspack dev server during development. Production builds use CGO_ENABLED=0 to produce a fully static, pure Go binary, and the official Docker images are built on Alpine Linux.

Server-side responsibilities

The installation guide's sizing section is a useful map of what the server process actually does: it covers "the UI, data source proxy, alert engine, and image renderer". Most SQL sources such as MySQL, PostgreSQL and Microsoft SQL Server hold an open connection per query on the server, while pull-based sources such as Prometheus or Graphite place less load on it, and some plugins query directly from the browser. In Grafana OSS the alert engine runs in the same process as the UI and data source proxy, which is why the docs recommend isolating alert evaluation onto dedicated instances at large scale.

Its own database

Grafana stores users, data sources, dashboards and other configuration in a database. Supported options are SQLite 3, MySQL 8.0+ and PostgreSQL 12+. By default it uses an embedded SQLite database stored in the installation location. The docs are direct that SQLite "isn't recommended for production environments" and that high availability requires MySQL or PostgreSQL. Running two or more instances also needs either a Redis session store or sticky sessions at the load balancer.

Data sources, query editors and plugins

Each data source comes with its own query editor tailored to that backend's query language, which can offer auto-completion, metric names, variable suggestions or a visual query builder depending on the source. Grafana ships built-in core data sources and accepts more through plugins. The Docker documentation says Grafana supports three plugin types: panel, data source and app. If no plugin exists for a system, you can build one with Grafana's plugin tools.

Configuration

Defaults live in conf/defaults.ini, which you are told not to edit. Custom settings go in custom.ini or, for deb and RPM packages, /etc/grafana/grafana.ini. Any existing option can be overridden with an environment variable of the form GF_<SECTION NAME>_<KEY>, and option values can pull from env, file and vault providers through variable expansion. One trap is called out explicitly: SAML, OAuth and LDAP settings saved through the SSO Settings API, the UI or Terraform are stored in the database and override the file, "and nothing in the UI or the file says so".

Key features

• Visualizations and panel plugins. The README describes fast and flexible client-side graphs with many options, and panel plugins add further ways to visualize metrics and logs.
• Dynamic dashboards with template variables. Variables appear as dropdowns at the top of a dashboard, so one dashboard can serve both a production and a test server, or drill down from all data to one region.
• Explore. Ad-hoc queries and dynamic drilldown, with a split view to compare different time ranges, queries and data sources side by side. For logs, the README highlights switching from metrics to logs with label filters preserved and streaming logs live.
• Grafana Alerting. Alert rules can combine queries and expressions from multiple data sources and send notifications through integrations such as PagerDuty, Slack, email, OpsGenie and VictorOps, with alert state managed from one consolidated view.
• Mixed data source. A panel can run each query against a different data source. Grafana runs those queries in parallel, and if one fails the others still return results.
• Dashboard data source. A panel can reuse another panel's result set instead of querying the backend again, which reduces load when several panels need the same data.
• Annotations. Mark graphs with events, created by hand with a control-click or fetched from any data source, to correlate changes with incidents.
• Correlations. Tracing data sources such as Tempo, Jaeger and Zipkin include trace-to-logs, trace-to-metrics and trace-to-profiles links, and the general Correlations feature links data between any data sources.
• Provisioning as code. Data sources, dashboards, plugin app configuration and alerting resources can be defined in version-controlled YAML and JSON files that Grafana applies at startup.
• Authentication and permissions. LDAP and OAuth are supported in the open source edition, with users mapped to organizations and permissions set on folders and dashboards for teams.

The built-in core data sources listed in the docs cover metrics (AWS CloudWatch, Azure Monitor, Google Cloud Monitoring, Graphite, InfluxDB, OpenTSDB, Prometheus), logs (Elasticsearch, Loki), traces (Jaeger, Tempo, Zipkin), profiles (Pyroscope), SQL databases (Microsoft SQL Server, MySQL, PostgreSQL), Alertmanager, and a TestData source for testing and debugging.

Getting started

The installation guide supports Debian or Ubuntu, RHEL or Fedora, SUSE or openSUSE, macOS and Windows; other operating systems are possible but "not recommended or supported". The minimum is 512 MB of memory and one CPU core, a floor for evaluation rather than production.

Docker

The Docker guide runs the latest stable version with one command:

docker run -d -p 3000:3000 --name=grafana grafana/grafana-enterprise

Two image names are documented: grafana/grafana-enterprise for Grafana Enterprise and grafana/grafana for Grafana Open Source. The docs call the Enterprise image the recommended and default edition, free and including all OSS features. They also warn that from release 12.4.0 the older grafana/grafana-oss Docker Hub repository is no longer updated and point to grafana/grafana instead.

Without a volume, Grafana's SQLite data lives inside the container and disappears when the container is removed. The documented full example creates a named volume, sets the root URL and preinstalls a plugin:

docker volume create grafana-storage

docker run -d -p 3000:3000 --name=grafana \
  --volume grafana-storage:/var/lib/grafana \
  -e "GF_SERVER_ROOT_URL=http://my.grafana.server/" \
  -e "GF_PLUGINS_PREINSTALL=grafana-clock-panel" \
  grafana/grafana-enterprise

The same setup in Docker Compose:

services:
  grafana:
    image: grafana/grafana-enterprise
    container_name: grafana
    restart: unless-stopped
    environment:
      - GF_SERVER_ROOT_URL=http://my.grafana.server/
      - GF_PLUGINS_PREINSTALL=grafana-clock-panel
    ports:
      - '3000:3000'
    volumes:
      - 'grafana_storage:/var/lib/grafana'
volumes:
  grafana_storage: {}

docker compose up -d

Debian or Ubuntu

The APT repository keeps Grafana updated with the rest of the system. Install prerequisites, import the GPG key, add the stable repository, then install the OSS package (grafana) or the Enterprise package (grafana-enterprise):

sudo apt-get install -y apt-transport-https wget gnupg
sudo mkdir -p /etc/apt/keyrings
sudo wget -O /etc/apt/keyrings/grafana.asc https://apt.grafana.com/gpg-full.key
sudo chmod 644 /etc/apt/keyrings/grafana.asc
echo "deb [signed-by=/etc/apt/keyrings/grafana.asc] https://apt.grafana.com stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list
sudo apt-get update
sudo apt-get install grafana

Start it with systemd and enable it at boot:

sudo systemctl daemon-reload
sudo systemctl start grafana-server
sudo systemctl enable grafana-server.service

Installs from a .deb package or .tar.gz binary have to be updated manually for each new version.

macOS and Kubernetes

On macOS, Homebrew installs and starts it:

brew update
brew install grafana
brew services start grafana

For Kubernetes, the Helm guide uses the community chart repository, a dedicated namespace and a port-forward to reach the UI:

helm repo add grafana-community https://grafana-community.github.io/helm-charts
helm repo update
kubectl create namespace monitoring
helm install my-grafana grafana-community/grafana --namespace monitoring
helm get notes my-grafana -n monitoring

The chart notes explain how to decode the generated admin password from a Kubernetes secret. The Helm page itself notes that the charts are offered by the open source community "without any warranties" and that problems go to the community-maintained repository.

First sign-in and configuration

Browse to http://localhost:3000, sign in with admin as both username and password, and Grafana prompts you to change the password. From there, add a data source under Connections (only organization admins can), then build a dashboard, optionally from the suggestions Grafana offers for that data source type. Configuration can be overridden with environment variables; the configuration reference shows, for example:

export GF_DEFAULT_INSTANCE_NAME=my-instance
export GF_SECURITY_ADMIN_USER=owner

Provisioning dashboards from files

To keep dashboards in Git, drop a provider file into the provisioning/dashboards directory. This example from the provisioning docs mirrors a folder tree on disk into Grafana folders:

apiVersion: 1

providers:
  - name: dashboards
    type: file
    updateIntervalSeconds: 30
    options:
      path: /etc/dashboards
      foldersFromFilesStructure: true

Data sources work the same way through YAML files in provisioning/datasources, with environment variable lookups such as $PASSWORD for secrets and an optional prune: true to delete data sources that disappear from the file.

Use cases

• Infrastructure and application monitoring. Point Grafana at Prometheus, Graphite, InfluxDB or a cloud provider's monitoring service and build dashboards per service or host, using template variables so one dashboard covers every environment.
• One pane for metrics, logs and traces. Combine Prometheus or Mimir metrics, Loki or Elasticsearch logs and Tempo, Jaeger or Zipkin traces, jumping between signals in Explore and through trace-to-logs links during an incident.
• Alerting across sources. Define alert rules that query several data sources and route notifications to Slack, PagerDuty, email or a webhook, provisioned from files so they are reviewed like code.
• Business and SQL dashboards. Use the built-in MySQL, PostgreSQL and Microsoft SQL Server data sources to chart application or business data without copying it into a metrics store.
• Automated environment setup. The introduction describes spinning up Grafana alongside a new Kubernetes cluster with the right server, data sources and dashboards preset and locked so users cannot change them. Community libraries exist for Puppet, Ansible, Chef and NixOS.
• Multi-team installations. Separate teams with organizations, folder and dashboard permissions and LDAP or OAuth sign-in, adding Enterprise features such as team sync or data source permissions where needed.

How it compares

The repository does not compare itself with other dashboarding tools, so the useful comparison is between Grafana's own editions and its companion projects.

The Enterprise premium data source list is worth checking before you commit: plugins for systems such as Datadog, Splunk, Snowflake, MongoDB, Oracle Database, ServiceNow, Jira, New Relic and Dynatrace require an Enterprise license.

Grafana Labs also publishes companion open source projects that the introduction lists separately: Loki (a logging stack), Tempo (distributed tracing backend), Mimir (scalable long-term storage for Prometheus), Pyroscope (continuous profiling), Faro (real user monitoring agent for web apps), Beyla (eBPF-based auto-instrumentation), Alloy (a distribution of the OpenTelemetry Collector), k6 (load testing) and OnCall (incident response). These are complements rather than alternatives: they store or collect the data that Grafana then queries. Because Grafana holds no telemetry itself, the main trade-off to evaluate is that it gives one interface over many backends, but you still run, size and secure those backends separately, as the sizing guide stresses.

Things to know before adopting

• AGPL-3.0, with Apache-2.0 exceptions. The LICENSE file is the GNU Affero General Public License version 3, and the README states Grafana is distributed under AGPL-3.0-only. The AGPL's network clause matters if you modify Grafana and let users interact with it over a network: you must offer those users the corresponding source. LICENSING.md lists directories under Apache-2.0 instead, including packages/grafana-data/, packages/grafana-e2e-selectors/, packages/grafana-runtime/, packages/grafana-ui/, packaging/, kinds/, pkg/kinds/, pkg/kindsys/, pkg/registry/schemas/, grafana-mixin/ and the Explore TraceView components, which matters for plugin authors building on those packages. public/vendor/ keeps its upstream licences, and one vendored workflow file is MIT.
• The recommended download is the Enterprise build. The Docker, Debian and macOS guides all describe Grafana Enterprise as the recommended and default edition, free to use and functionally identical to OSS until you unlock features with a license. If you specifically want the open source build, choose the grafana/grafana image or the grafana package explicitly.
• Change the default admin credentials. On first start Grafana creates an admin user with username admin and password admin (email admin@localhost). The sign-in guide strongly recommends changing the password, and admin_user and admin_password can be set in configuration or through GF_SECURITY_* variables before first run. cookie_secure defaults to false and should be enabled behind HTTPS.
• Usage reporting is on by default. With reporting_enabled at its default of true, Grafana sends anonymous usage statistics to stats.grafana.org every 24 hours. The docs say it tracks counters of running instances, versions, dashboards and errors, not IP addresses. Separate options check GitHub and grafana.com for Grafana and plugin updates every ten minutes. Set these to false in the [analytics] section if your environment requires no outbound calls.
• Viewers can query more than they see. The security guide warns that a user with the Viewer role can send any query to any data source in the organization, not just the queries on dashboards they can open. Restricting this needs separate data sources with limited credentials plus the Enterprise data source permissions feature, or separate organizations. Anonymous access widens this to anyone with the URL.
• The data source proxy can reach internal services. If other web services run on the Grafana host or its network, the docs recommend a data_source_proxy_whitelist, firewall rules or an outbound proxy. The request security feature that limits outgoing requests is Enterprise-only.
• Plan the database early. SQLite is the default but not recommended for production, and moving to MySQL or PostgreSQL later is described as a customer-managed operation outside the scope of Grafana Support. The docs also list a known issue with read-only MySQL servers, such as during high-availability failover or with serverless AWS Aurora MySQL.
• Sizing scales with users and alerts. The documented tiers start at 2 cores and 2 to 4 GB of memory for small deployments and go to three or more load-balanced instances with 8 to 16+ cores each. Image rendering needs roughly 1 GB of memory per renderer worker, and more than 1,000 alert rules or sub-minute evaluation intervals can saturate CPU and slow dashboards on the same instance.
• Provisioned dashboards overwrite UI edits. If you save a provisioned dashboard in the UI and later update the file, the file wins, and removing the provisioning source deletes the dashboard unless disableDeletion is set. With updateIntervalSeconds of 10 or less, Grafana relies on filesystem watch events that may not arrive through Docker bind mounts or some network filesystems.

Project activity

As of November 2026 the repository has about 77,800 stars on GitHub. It was created in December 2013, GitHub reports TypeScript as its primary language (the backend is Go), and the default branch is main. The code is licensed under AGPL-3.0-only, with the Apache-2.0 directories listed in LICENSING.md. Contributors are pointed to a contributing guide, a developer guide and beginner-friendly issues, and signed commits are required.

Community support runs through the forums at community.grafana.com and an official Slack. A live demo instance is available at play.grafana.org. The source, issues and releases are at github.com/grafana/grafana, documentation is at grafana.com/docs, and the project homepage is grafana.com.