Feature Request: ConfigMap-based Dashboard Provisioning (Grafana-style sidecar)

[heiba]

Feature Request

Description

Add support for automatically provisioning dashboards from Kubernetes ConfigMaps, similar to Grafana's sidecar provisioner approach. This would enable GitOps workflows and Infrastructure-as-Code management of HyperDX dashboards.

Use Case

As a DevOps engineer managing ClickStack on Kubernetes, I want to:

• Store dashboard JSON files in Git alongside my infrastructure code
• Deploy dashboards declaratively via ConfigMaps or Helm values
• Automatically sync dashboard changes without manual UI interaction
• Maintain consistency across multiple environments (dev/staging/prod)

Proposed Solution

A sidecar container (or init container) that:

1. Watches a ConfigMap or a mounted volume for dashboard JSON files
2. Automatically imports/updates dashboards in HyperDX via the API
3. Optionally supports annotations to control behavior (e.g., folder assignment, overwrite policy)

Example usage:

apiVersion: v1
kind: ConfigMap
metadata:
  name: hyperdx-dashboards
  labels:
    hyperdx-dashboard: "true"
data:
  k8s-overview.json: |
    { "name": "Kubernetes Overview", "charts": [...] }

Alternatives Considered

• Manual import via UI (not scalable, not GitOps-friendly)
• Custom Job/CronJob calling the dashboard API (works but requires custom implementation per deployment)
• Direct MongoDB seeding (fragile, bypasses API validation)

References

• Grafana sidecar provisioner: https://github.com/grafana/helm-charts/tree/main/charts/grafana#sidecar-for-dashboards
• HyperDX Dashboard API: https://www.hyperdx.io/docs/api/dashboards
• Recent dashboard import/export feature (Sept 2025): https://clickhouse.com/blog/whats-new-in-clickstack-september-2025

Environment

• Deployment: Kubernetes (RKE2)
• Helm chart: clickstack/clickstack

[heiba]

@dhable How can I help on this issue ? I really need anyway to deploy saved dashboards using terraform so that when I deploy the clickstack instance I can then automate the creation of all the saved dashboards I need

[heiba]

@dhable I asked Claude this question "Is there a way in hyperdx to export saved views outside the hyperdx website and then load them back in ? like grafana dashboards"

It replied with: https://claude.ai/share/a3de0357-efee-40c4-847a-8528942e7458

HyperDX doesn't have a native UI-based export/import feature like Grafana's dashboard JSON. However, there are two practical approaches you can use:

1. REST API (Best option)

HyperDX exposes a dashboards API at GET /api/v1/dashboards and GET /api/v1/dashboards/{id} that returns the full dashboard definition including all charts, series, aggregation functions, and data sources. You can use this to export/import programmatically:

# Export all dashboards
curl -s https://api.hyperdx.io/api/v1/dashboards \
  -H "Authorization: Bearer YOUR_API_KEY" | jq . > dashboards-backup.json

# Export a specific dashboard
curl -s https://api.hyperdx.io/api/v1/dashboards/YOUR_DASHBOARD_ID \
  -H "Authorization: Bearer YOUR_API_KEY" | jq . > dashboard-xyz.json

To import back, you'd use the POST /api/v1/dashboards endpoint with the exported JSON payload (you may need to strip the _id/id fields so the server generates new ones).

2. Direct MongoDB Access (if self-hosted)

Since you're running HyperDX self-hosted on Kubernetes, HyperDX stores all its state in MongoDB, with collections including dashboards and savedsearches. You can directly mongodump/mongorestore specific collections:

# Export dashboards collection
mongodump --uri="mongodb://..." --db=hyperdx --collection=dashboards --out=./backup

# Export saved searches
mongodump --uri="mongodb://..." --db=hyperdx --collection=savedsearches --out=./backup

Bottom line: There's no Grafana-style one-click JSON export from the UI, but the API approach is clean enough to script. Given you're self-hosted, the MongoDB route gives you the most control — useful for migrations between your test/live environments. Would you want a script that automates the API-based backup/restore?

I then asked "ok ill use the APIs then, need to use it in terraform create dashboards automatically"

It then replied with:

There's no official HyperDX Terraform provider, but you can use the restapi provider (mastercard/restapi) which lets you manage any REST API as Terraform resources. Here's how to set it up:

Provider setup (providers.tf):

terraform {
  required_providers {
    restapi = {
      source  = "Mastercard/restapi"
      version = "~> 1.19"
    }
  }
}

provider "restapi" {
  uri                  = "https://api.hyperdx.io"
  write_returns_object = true

  headers = {
    "Authorization" = "Bearer ${var.hyperdx_api_key}"
    "Content-Type"  = "application/json"
  }

  create_method  = "POST"
  update_method  = "PUT"
  destroy_method = "DELETE"

  id_attribute = "data/_id"
}

variable "hyperdx_api_key" {
  type      = string
  sensitive = true
}

A reusable dashboard module (modules/hyperdx_dashboard/main.tf):

variable "name" { type = string }
variable "charts" { type = any }

resource "restapi_object" "dashboard" {
  path         = "/api/v1/dashboards"
  id_attribute = "data/_id"

  data = jsonencode({
    name   = var.name
    charts = var.charts
  })
}

output "id" {
  value = restapi_object.dashboard.id
}

Example dashboard usage (dashboards.tf):

module "my_org_errors_dashboard" {
  source = "./modules/hyperdx_dashboard"

  name = "My Org - Errors Overview"

  charts = [
    {
      name = "Error Rate"
      x = 0; y = 0; w = 6; h = 3
      series = [{
        type       = "time"
        dataSource = "events"
        aggFn      = "count"
        where      = "level:error"
        groupBy    = ["ServiceName"]
      }]
    },
    {
      name = "P95 Response Time"
      x = 6; y = 0; w = 6; h = 3
      series = [{
        type       = "time"
        dataSource = "events"
        aggFn      = "p95"
        field      = "duration"
        where      = "level:error"
      }]
    }
  ]
}

Key things to note:

• The id_attribute = "data/_id" is critical — HyperDX wraps responses in { data: { _id: "..." } } so the provider knows how to track the resource after creation.
• For updates, the PUT /api/v1/dashboards/{id} endpoint expects the full dashboard payload, which restapi handles automatically.
• Store your API key in Terraform Cloud secrets or as a Kubernetes secret fed into your CI/CD — don't hardcode it.
• Since you already manage Cloudflare and K8s resources in separate Terraform workspaces, I'd suggest a dedicated hyperdx workspace to keep it clean.

Want me to build out a full working example with your typical microservices service dashboards (error rates, latency, pod health, etc.)?

What do you think ?

[ZeynelKoca]

This feature would be really useful for our team as well and IMO absolutely necessary for increasing the maturity of production systems based on ClickStack / HyperDX