Platform Deep Dive: Grafana Cloud

The LGTM Stack

Grafana Cloud is built on four open-source projects — collectively called the LGTM stack — each purpose-built for a specific telemetry signal. Unlike monolithic platforms that use a single proprietary backend, Grafana Labs maintains dedicated, horizontally-scalable systems optimized for each data type.

flowchart TD
    A[Applications & Infrastructure] --> B[OTel Collector / Grafana Agent / Alloy]
    B --> C[Grafana Mimir — Metrics]
    B --> D[Grafana Loki — Logs]
    B --> E[Grafana Tempo — Traces]
    C --> F[Grafana Dashboards]
    D --> F
    E --> F
    F --> G[Alertmanager / Grafana OnCall]

    style A fill:#3B9797,color:#fff
    style B fill:#132440,color:#fff
    style C fill:#BF092F,color:#fff
    style D fill:#16476A,color:#fff
    style E fill:#16476A,color:#fff
    style F fill:#3B9797,color:#fff
    style G fill:#132440,color:#fff
                            

The critical architectural advantage: every protocol is open. Mimir speaks Prometheus remote_write, Loki accepts standard syslog and Fluentd protocols, and Tempo ingests OpenTelemetry, Jaeger, and Zipkin natively. You can migrate away from Grafana Cloud at any time without rewriting instrumentation — the same agents and SDKs work with self-hosted versions.

Grafana Mimir (Managed Metrics)

Grafana Mimir is the metrics backend powering Grafana Cloud — a horizontally scalable, multi-tenant Prometheus-compatible time-series database. If you already know PromQL, you know how to query Mimir. It's designed to handle billions of active series with consistent query performance.

Prometheus vs Mimir Comparison

Sending Metrics to Grafana Cloud

# Grafana Alloy configuration for remote_write to Grafana Cloud
prometheus.remote_write "grafana_cloud" {
  endpoint {
    url = "https://prometheus-prod-01-eu-west-0.grafana.net/api/prom/push"

    basic_auth {
      username = env("GRAFANA_CLOUD_PROM_USER")
      password = env("GRAFANA_CLOUD_API_KEY")
    }
  }

  queue_config {
    max_samples_per_send = 1000
    batch_send_deadline  = "5s"
    min_backoff          = "30ms"
    max_backoff          = "5s"
  }
}

Grafana Loki (Managed Logs)

Grafana Loki takes a fundamentally different approach to log storage than Elasticsearch or Splunk. Instead of full-text indexing every log line, Loki only indexes labels (metadata like pod name, namespace, service) and stores log content in compressed chunks on cheap object storage. This makes it orders of magnitude cheaper to operate at scale.

LogQL Query Examples

# Basic log stream selection by labels
{namespace="production", app="checkout-service"}

# Filter log lines containing specific text
{namespace="production", app="checkout-service"} |= "error"

# Regex filter with JSON parsing
{namespace="production"} | json | status_code >= 500

# Log-based metrics — count errors per minute
rate({namespace="production", app="checkout-service"} |= "error" [5m])

# Top 5 pods by error count
topk(5, sum by(pod) (rate({namespace="production"} |= "error" [5m])))

Grafana Alloy Log Collection Config

# Grafana Alloy — collect logs from Kubernetes pods
loki.source.kubernetes "pods" {
  targets    = discovery.kubernetes.pods.targets
  forward_to = [loki.write.grafana_cloud.receiver]
}

# Add labels and process log lines
loki.process "pipeline" {
  forward_to = [loki.write.grafana_cloud.receiver]

  stage.json {
    expressions = {
      level   = "level",
      message = "msg",
      trace_id = "trace_id",
    }
  }

  stage.labels {
    values = {
      level = "",
    }
  }

  stage.timestamp {
    source = "timestamp"
    format = "RFC3339"
  }
}

# Write to Grafana Cloud Loki endpoint
loki.write "grafana_cloud" {
  endpoint {
    url = "https://logs-prod-eu-west-0.grafana.net/loki/api/v1/push"

    basic_auth {
      username = env("GRAFANA_CLOUD_LOKI_USER")
      password = env("GRAFANA_CLOUD_API_KEY")
    }
  }
}

Grafana Tempo (Managed Traces)

Grafana Tempo is a distributed tracing backend that stores traces on object storage without any indexing. It relies on trace IDs for direct lookups, and the newer TraceQL query language for searching across trace attributes. Like Loki, this architecture makes it extremely cost-effective at scale.

Tempo vs Jaeger Comparison

TraceQL Query Examples

# Find traces where checkout service had errors
{ resource.service.name = "checkout-service" && status = error }

# Find slow database spans (> 500ms)
{ span.db.system = "postgresql" && duration > 500ms }

# Find traces crossing service boundaries with high latency
{ resource.service.name = "api-gateway" && duration > 2s } >> { resource.service.name = "payment-service" }

# Search by custom span attribute
{ span.http.status_code >= 500 && resource.deployment.environment = "production" }

# Aggregate — count errors per service
{ status = error } | count() by (resource.service.name)

Grafana Alerting

Grafana Cloud provides a unified alerting system that can evaluate alert rules against any data source — Mimir (Prometheus), Loki (logs), Tempo (traces), and even external sources like Elasticsearch or CloudWatch. Alert rules are defined using the same query languages (PromQL, LogQL) and managed alongside dashboards.

Alerting Components Comparison

Alert Rule Example (PromQL)

# Grafana Alert Rule — High Error Rate
apiVersion: 1
groups:
  - orgId: 1
    name: production-alerts
    folder: SRE
    interval: 1m
    rules:
      - uid: high-error-rate
        title: "High Error Rate - Checkout Service"
        condition: C
        data:
          - refId: A
            datasourceUid: grafana-cloud-prom
            model:
              expr: |
                sum(rate(http_requests_total{service="checkout", status=~"5.."}[5m]))
                /
                sum(rate(http_requests_total{service="checkout"}[5m]))
              instant: true
          - refId: C
            datasourceUid: __expr__
            model:
              type: threshold
              conditions:
                - evaluator:
                    type: gt
                    params: [0.05]
        noDataState: NoData
        execErrState: Error
        for: 5m
        labels:
          severity: critical
          team: checkout
        annotations:
          summary: "Checkout error rate above 5%"
          runbook_url: "https://wiki.internal/runbooks/checkout-errors"

Synthetic Monitoring & k6

Grafana Cloud includes synthetic monitoring for probing endpoints from global locations, plus native k6 Cloud integration for load testing. Synthetic checks run from Grafana's global probe network (or your private probes) and report availability, latency, and certificate status directly into Grafana dashboards.

Synthetic Check Types

k6 Cloud Integration

Grafana acquired k6 (the popular open-source load testing tool) and integrated it directly into Grafana Cloud. You can run load tests from the CLI, visualize results in Grafana dashboards, and set performance thresholds as pass/fail gates in CI/CD pipelines.

# Run a k6 load test and stream results to Grafana Cloud
k6 run --out cloud script.js

# Example k6 script for load testing
# (save as script.js)
import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 100 },  // Ramp up
    { duration: '5m', target: 100 },  // Stay at 100 users
    { duration: '2m', target: 0 },    // Ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],  // 95% of requests under 500ms
    http_req_failed: ['rate<0.01'],    // Less than 1% failures
  },
};

export default function () {
  const res = http.get('https://api.example.com/health');
  check(res, {
    'status is 200': (r) => r.status === 200,
    'response time < 500ms': (r) => r.timings.duration < 500,
  });
  sleep(1);
}

Pricing & Free Tier

Grafana Cloud stands out with one of the most generous free tiers in the observability market — and transparent, usage-based pricing that avoids per-seat or per-host models for the core platform.

Tier Comparison

Cost Optimization Strategies

1. Reduce active series cardinality — Use recording rules to pre-aggregate high-cardinality metrics and drop unused labels at the agent level. A 10x reduction in series count translates directly to 10x cost reduction.
2. Use Adaptive Metrics — Grafana Cloud's built-in feature identifies metrics that aren't queried by any dashboard or alert rule. Automatically aggregate or drop unused series to eliminate waste.
3. Filter logs at the agent — Drop debug/trace-level logs before they reach Loki. Use Alloy's pipeline stages to filter, redact, or sample verbose log streams.
4. Implement trace sampling — Use tail-based sampling in Grafana Alloy to keep only interesting traces (errors, high-latency, specific services) and drop routine traces.
5. Leverage the free tier strategically — Use the free tier for staging/dev environments. Reserve paid capacity for production workloads only.
6. Set usage alerts — Configure billing alerts in Grafana Cloud to notify before usage spikes cause bill shock. Set hard limits per data source.

When to Choose Grafana Cloud

Platform Comparison Summary

Having explored Datadog, New Relic, and Grafana Cloud in depth, here's a consolidated comparison to guide your platform selection decision: