Przejdź do treści
Biblioteka skilli
DevOps i chmura · Konwersja i formaty

splunk-dashboard

/splunk-dashboard

Generuje Terraform dla dashboardów Splunk Observability Cloud z raportu otel-audit, grupując metryki w gotowe do zastosowania panele.

Repozytorium
obstudio ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
27.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
3
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Generuje Terraform dla dashboardów Splunk Observability Cloud z raportu otel-audit, grupując metryki w gotowe do zastosowania panele.

Wyzwalacze z opisu

generate a dashboardbuild a dashboard from the auditcreate charts for my servicevisualize my metrics
Oryginalny opis (EN)

Generate Splunk Observability Cloud dashboard Terraform from an existing otel-audit report. Reads .observe/otel-audit.json, groups metrics into dashboard panels, and outputs ready-to-apply HCL (signalfx_dashboard_group + signalfx_dashboard + per-panel signalfx_*_chart resources) plus a sidecar preview model for the local Splunk Observability Studio. Use when the user types $splunk-dashboard, asks to "generate a dashboard", "build a dashboard from the audit", "create charts for my service", or "visualize my metrics".

Jak działa

  1. Overview
  2. When to Use
  3. Process
  4. Red Flags
Sekcje z nagłówków SKILL.md, w oryginale · 267 linii, 1 467 słów
Podgląd SKILL.md
---
name: splunk-dashboard
description: >-
  Generate Splunk Observability Cloud dashboard Terraform from an existing
  otel-audit report. Reads .observe/otel-audit.json, groups metrics into
  dashboard panels, and outputs ready-to-apply HCL (signalfx_dashboard_group +
  signalfx_dashboard + per-panel signalfx_*_chart resources) plus a sidecar
  preview model for the local Splunk Observability Studio. Use when the user types
  $splunk-dashboard, asks to "generate a dashboard", "build a dashboard from
  the audit", "create charts for my service", or "visualize my metrics".
allowed-tools: Read, Write, Grep, Glob
metadata:
  author: otel-studio
  version: 0.1.0
  category: observability
---

# Dashboard -- Splunk O11y Dashboard Terraform from Audit Report

## Overview

Read an existing `.observe/otel-audit.json` audit report, group detected metrics
into dashboard panels (RED-style layout), and generate Terraform for Splunk
Observability Cloud `signalfx_dashboard_group`, `signalfx_dashboard`, and
per-panel `signalfx_*_chart` resources with inline SignalFlow `program_text`.
Also emit a sidecar `.observe/dashboards.preview.json` that the local Splunk Observability Studio's
**Dashboards** tab renders against live OTLP data as an approximate preview.

This is the visualization analogue of `$splunk-configure` (which generates
detectors). It shares its parsing rules and SignalFlow fragments; it differs in
that a dashboard is a three-level object — group → dashboard → charts[] — where
each chart is a separate resource placed on a 12-column grid.

## When to Use

- After running `$otel-audit` to generate `.observe/otel-audit.json`
- When the user wants a dashboard / charts / a visual overview for their service
- When the user wants to preview a dashboard layout locally before pushing it to
  Splunk (Splunk Observability Studio Dashboards tab reads the preview sidecar this skill writes)

**When NOT to use:** If no audit report exists yet, instruct the user to run
`$otel-audit` first. For alerting/detection Terraform, use `$splunk-configure`.
To push the generated dashboards to a live org, use `$splunk-dashboard-publish`.

## Process

### Step 1 -- Locate Audit Report

Look for `.observe/otel-audit.json` in the repository root.

- If the file exists, proceed to Step 2.
- If the file is missing, stop and respond:

> No audit report found at `.observe/otel-audit.json`. Please run `$otel-audit` first
> to generate the observability coverage report.

### Step 2 -- Parse Service Metadata, Metrics, and GenAI Coverage

Extract from `.observe/otel-audit.json`, using the same parsing rules
`$splunk-configure` documents:

1. **Service metadata** from the JSON metadata and service fields: service
   name, language, framework.
2. **Existing metrics** from `current_instrumentation.metrics`. Each metric
   provides its name, source/evidence, and auto/custom ownership when known.
   Record only source-backed existing metrics for grouping in Step 3. Findings
   and `expected_telemetry` describe desired instrumentation and become
   prerequisites, not dashboard panels.
3. **GenAI readiness** from the JSON readiness/finding fields when present.
   GenAI metrics that exist become their own dashboard group; missing GenAI
   areas become preview/instrumentation prerequisites, not invented panels.

If `current_instrumentation.metrics` is empty and there are no explicitly
proven downstream metrics, stop and respond:

> The audit report contains no metrics. Dashboards require metric data.
> Run `$otel-instrument` to add instrumentation, then re-run `$otel-audit`.

### Step 3 -- Group Metrics into Panels

Load `references/dashboard-classification.md` and apply its grouping rules to
each metric from Step 2. Each metric maps to a panel with a chart type and a grid
placement:

- **Overview KPI row (top):** a row of `single_value` panels — one per RED
  signal that exists (p99 latency, error rate, throughput) plus key saturation
  gauges — giving an at-a-glance service summary.
- **Latency** (duration histograms) → a `time_series` percentile panel.
- **Error** (counters whose name carries an error keyword — e.g.
  `checkout.payment.errors`, `http.server.errors.total` — keyed on counter-ness,
  not a required `.total`/`.count` suffix) → a `time_series` error-rate panel.
- **Throughput** (non-error counters — e.g. `checkout.orders.processed`,
  `http.server.requests.total` — same counter test, no error keyword) → a
  `time_series` rate panel.
- **Saturation** (gauges: connections, queues, buffers, lag) → a `single_value`
  panel (and optionally a `time_series` trend panel).
- **GenAI** metrics (when present) → their own `signalfx_dashboard` inside a
  GenAI dashboard group, with latency/token/provider/tool panels.

Skip metrics that match the exclusion rules (auto-instrumented library
duplicates, informational-only gauges). Record skipped metrics with a reason for
the report.

### Step 4 -- Generate Terraform

Create the output directory `.observe/terraform/` if it does not exist. Generate
three files using `references/dashboard-templates.md` plus the shared
`../references/signalflow-patterns.md` for chart `program_text`:

#### `.observe/terraform/dashboards.tf`

- One `signalfx_dashboard_group` (plus a second GenAI group when GenAI metrics
  exist).
- One or more `signalfx_dashboard` referencing the group.
- One `signalfx_<type>_chart` per panel (`signalfx_time_chart`,
  `signalfx_single_value_chart`, etc.), with SignalFlow `program_text` built from
  the shared `signalflow-patterns.md` fragment (no `detect()/when()/threshold()`
  tail — charts only visualize).
- Each chart is placed via the dashboard's `chart { chart_id = ...; column; row;
  width; height }` block on the 12-wide grid: `column` 0-11, `width` 1-12,
  `row` ≥0, `height` ≥1.

Sanitize metric names for HCL identifiers: replace dots and hyphens with
underscores, strip leading digits.

#### `.observe/terraform/variables.tf`

> **REQUIRED: `sensitive = true` on `api_token` — no exceptions.**
> The `api_token` variable MUST include `sensitive   = true`. Omitting it is a
> hard failure: Terraform will log the value in plaintext. Copy the block below
> exactly; do not remove `sensitive = true`.

```hcl
variable "realm" {
  description = "Splunk Observability Cloud realm (e.g. us1, eu0)"
  type        = string
}

variable "api_token" {
  description = "Splunk Observability Cloud API token"
  type        = string
  sensitive   = true   # REQUIRED — must always be present
}

variable "service_name" {
  description = "Service name for dashboard naming and chart filters"
  type        = string
  default     = "<service-name from report>"
}
```

`api_token` is always `sensitive = true` — it is a secret and must never be
logged, written into a report, or committed with a real value.

#### `.observe/terraform/terraform.tfvars.example`

```hcl
realm        = ""   # e.g. us1, eu0, lab0
api_token    = ""   # Splunk O11y API token (org-level, dashboard write)
service_name = "<service-name from report>"
```

### Step 5 -- Emit Splunk Observability Studio Preview Sidecar

Write `.observe/dashboards.preview.json` for the local Splunk Observability Studio Dashboards tab.
Because this skill already resolves `${var.*}` and dedents the `<<-EOF` heredocs
while writing HCL (per `../references/terraform-normalization.md`), write the
**fully-resolved** `programText` here — Splunk Observability Studio does no HCL parsing.

```jsonc
{
  "schemaVersion": 1,
  "generatedAt": "<RFC3339 timestamp>",
  "groups": [
    {
      "name": "<service-name> Overview",
      "description": "RED + saturation dashboard for <service-name>",
      "dashboards": [
        {
          "name": "<service-name> RED",
          "description": "Rate, errors, duration",
          "charts": [
            {
              "label": "p99_latency",
              "title": "P99 Latency",
              "chartType": "time_series",
              "programText": "data('http.server.request.duration', filter=filter('service.name','<service>')).percentile(pct=99).publish(label='P99 Latency')",
              "text": null,
              "layout": { "column": 0, "row": 0, "width": 6, "height": 3 }
            }
          ]
        }
      ]
    }
  ]
}
```

- `chartType` ∈ `time_series | single_value | list | heatmap | text | table`.
- `programText` carries the resolved SignalFlow (no `${var.*}`, dedented). For a
  `text` panel, set `programText: null` and put the markdown in `text`.
- `layout` mirrors the HCL `chart {}` block exactly: `column` 0-11, `row` ≥0,
  `width` 1-12, `height` ≥1. The grid is 12 columns wide.

Keep the preview sidecar in lockstep with `dashboards.tf`: every chart in the HCL
appears exactly once in the sidecar with the same label, type, resolved query,
and grid placement.

### Step 6 -- Generate Report

Create `.observe/dashboards.md` as a human-readable companion:

```markdown
# Dashboards Report: <service-name>

**Language:** <lang> | **Framework:** <framework> | **Date:** <YYYY-MM-DD>
**Source:** `.observe/otel-audit.json` | **Output:** `.observe/terraform/`

## Summary

| Dashboard | Group | Panels | Chart Types |
|-----------|-------|--------|-------------|
| <service> RED | <service> Overview | N | single_value, time_series |

## Panels

| # | Panel | Metric | Chart Type | Grid (col,row,w,h) | Rationale |
|---|-------|--------|------------|--------------------|-----------|
| 1 | P99 Latency | http.server.request.duration | time_series | 0,0,6,3 | latency histogram → percentile time series |

## Grid Map

<ASCII or table sketch of the 12-column placement per dashboard>

## Skipped Metrics

| Metric | Reason |
|--------|--------|

## GenAI Instrumentation Prerequisites

<when canonical genai_readiness, GenAI findings, or bound proof shows a required signal is missing>

## Next Steps

1. `cp .observe/terraform/terraform.tfvars.example .observe/terraform/terraform.tfvars`
2. Fill in `realm` and `api_token`
3. Preview locally: open Splunk Observability Studio **Dashboards** tab (localhost:17900)
4. Push to Splunk: `$splunk-dashboard-publish` (REST-direct, creates only gaps)
   or `cd .observe/terraform && terraform init && terraform apply`

---
*Generated by splunk-dashboard on <YYYY-MM-DD>*
```

### Step 7 -- Chat Summary

After all files are written, present a concise summary: the dashboards/panels
generated, the files written (`dashboards.tf`, `variables.tf`,
`terraform.tfvars.example`, `.observe/dashboards.md`,
`.observe/dashboards.preview.json`), and the next steps — preview in Splunk Observability Studio
Dashboards tab, then `$splunk-dashboard-publish` or `terraform apply`.

This skill never runs `terraform` and has no bundled validator script (unlike
`$splunk-configure`). Do not report "Validation passed," "verified," or any
similar status for the generated Terraform or `.observe/dashboards.preview.json`
in the chat summary, even when an internal sanity check (for example a JSON
parse or a grep for unresolved variables) happened to succeed while authoring
the files. State only what was generated and direct the user to run
`terraform validate`/`terraform plan` or `$splunk-dashboard-publish` next.

## Red Flags

- `api_token` variable in `variables.tf` is missing `sensitive = true` — this is a hard requirement; the token is a secret and must never be logged or committed as plaintext.
- Audit report has no metrics section and no GenAI readiness — nothing to chart.
- A chart's resolved `programText` still contains a literal `${var.*}` — the
  preview sidecar and any future POST will fail; resolve every variable per
  `../references/terraform-normalization.md` before writing.
- A panel's grid placement overflows the 12-column grid (`column + width > 12`)
  — clamp or re-place it; Splunk Observability Studio preview clamps defensively but the HCL
  should be correct.
- Service name contains characters invalid for a SignalFlow filter value.
Pliki w paczce (3)
  • SKILL.md 12 KB
  • references/dashboard-classification.md 7 KB
  • references/dashboard-templates.md 6 KB

Wersje

W bazie nie ma innych skilli o nazwie splunk-dashboard.

Identyczna treść występuje jeszcze w 1 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.

Migawka bazy z 13.11.2026 · wersja paczki c90ba48219e7 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 91splunk-configure
    Generuje Terraform dla detektorów i dashboardów Splunk Observability Cloud na podstawie raportów obserwowalności, z zapytaniami SignalFlow.
  • 100splunk-dashboard-publish
    Porównuje lokalny Terraform dashboardów Splunk z działającymi dashboardami i tworzy wyłącznie potwierdzone luki.
  • 100splunk
    Obsługuje Splunk Enterprise i Splunk Cloud jako platformę logów i metryk: SPL, architekturę rozproszoną, ingest, dashboardy, alerty i koszty licencji.
  • 100metrics-dashboard-generator
    Generuje konfigurację scrape Prometheus i dashboard Grafana w JSON dla metryk usługi .NET: panele RED i USE dla żądań, błędów, opóźnień, GC i własnych mierników.
  • 100workflow-triaging
    Klasyfikuje problemy z AEM Workflow w AEM as a Cloud Service: rozpoznaje objawy, zbiera właściwe logi i metryki oraz kieruje do runbooków lub wyszukiwań Splunk.
  • 95otel-observability
    Obsługuje OpenTelemetry: śledzenie, metryki, logi, instrumentację, eksportery i propagację kontekstu, przy dodawaniu tracingu, metryk i logowania oraz pracy ze spanami.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.