Generated banner for Loki Label Analyzer
Generated logo for Loki Label Analyzer

Loki Label Analyzer

Grafana LabsOfficialPublished by Grafana Labs

  • Skill
  • Review and audit
  • Cloud and DevOps
  • Apache-2.0
  • No issues found

From the author

Expert evaluator for Grafana Loki label strategy. Audits, designs, and improves label schemas using cardinality scoring, access-pattern alignment, static vs. dynamic label rules, and consistency checks. Use when the user asks to evaluate, audit, design, or improve a Loki label strategy — or asks why their Loki queries are slow.
— the description by Grafana Labs

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The Loki Label Strategy Evaluator provides a structured framework for auditing and refining label schemas in Grafana Loki. It helps users identify performance bottlenecks caused by high-cardinality labels, provides guidance on normalizing label values, and offers best practices for migrating transient labels like 'pod' to structured metadata. The skill ensures that critical correlation labels are protected while providing actionable steps to reduce stream counts and improve query efficiency.

What it does

  • Audits existing label schemas for cardinality and access-pattern alignment.
  • Provides a structured report format for label strategy improvements.
  • Offers guidance on demoting high-cardinality labels to structured metadata.
  • Ensures protection of critical correlation labels like service_name and job.
  • Diagnoses query performance bottlenecks using Loki metrics.
  • Suggests Alloy/Agent configuration patterns for label normalization.

When to use it

  • When users report slow Loki queries or high index storage costs.
  • When designing a new log collection strategy for Kubernetes or VM environments.
  • When auditing existing label sets to reduce stream count and improve performance.
  • When needing to migrate from high-cardinality labels to structured metadata.

Advantages

  • Reduces query latency by improving label selectivity.
  • Lowers index storage overhead by consolidating stream counts.
  • Prevents accidental removal of critical correlation labels.
  • Provides a standardized, professional audit report structure.
  • Offers specific, actionable configuration snippets for Alloy/Agent.

Usage examples

“Why are my Loki queries so slow?”
The agent will initiate a performance diagnosis, checking for high-cardinality labels, insufficient label selectivity, and potential infrastructure bottlenecks using the Four Query Stages framework.
“Audit my current Loki label strategy.”
The agent will request your current label set and provide a structured audit report, including cardinality scoring, downstream dependency checks, and recommended migration steps.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/grafana/loki-label-analyzer/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip loki-label-analyzer.zip -d .agents/skills

Documentation by Grafana Labs

Loki Label Strategy Evaluator

You are an expert in Grafana Loki label strategy. When asked to evaluate, audit, design, or improve a Loki label strategy — or when a user asks why their Loki queries are slow — use this guide to provide structured, actionable advice.


Core Concepts

Streams are the fundamental unit in Loki. Each unique combination of label key-value pairs creates a new stream. Too many streams = performance problems. Too few = broad, slow queries.

Cardinality = the number of unique values a label can have. High-cardinality labels (like pod, user_id, request_id) dramatically increase stream count and hurt performance — especially when those labels are not specified in every query.

The dual impact rule: High-cardinality labels hurt on both paths:

  • Ingestion path: More streams → larger index, higher storage costs

  • Query path: If a high-cardinality label exists but isn't in the query selector, Loki must scan ALL streams matching the other selectors — catastrophic for performance

The key question for any dynamic label: "Will this label be used in 9 out of 10 queries?" If no → it should NOT be a label — except platform / correlation labels (below).

Platform / correlation labels are exempt from drop recommendations. Never recommend dropping service_name, deployment_environment, or job when present. Bad cardinality on those keys is a value problem (stabilize identities); dropping the key breaks Grafana Cloud correlation, App O11y, alerts, and dashboards. Load references/protected-labels.md before any demote/label_keep advice.


Label Evaluation Framework

When auditing a label strategy, assess each label against these criteria.

Cardinality Scoring
Label ExampleCardinalityVerdict
service_name / deployment_environment / jobAny✅ Keep key — remediate values if high-card (never drop)
env (prod/staging/dev)2–5 values✅ Good
level (info/warn/error)3–6 values✅ Good
namespace (K8s)Tens✅ Acceptable
instance / hostnameHundreds–thousands⚠️ Evaluate access patterns
podThousands + transient⚠️ Demote off index (structured metadata) — migrate selectors first
user_id, request_idUnbounded❌ Never use as label
Access Pattern Alignment

For each label, ask:

  • Is this label on the protected allowlist? If yes → Keep key; remediate values only (protected-labels.md)

  • Is this label used as a selector in most queries targeting these logs?

  • Does this label logically segment data in the way users think about it?

  • Would demoting this label break alerts, dashboards, LBAC, or correlation without a migration plan?

  • Would demoting this label force users to scan dramatically more data?

Static vs. Dynamic Label Values
  • Static labels (values don't change per log line, e.g., platform=linux, job=agent) add no cardinality cost relative to the query scope. Use freely for LBAC, exploration, and alert routing.

  • Dynamic labels (values change per log line) must be bounded. Keep possible values in the single digits or low tens.

Consistency Check
  • Are label names consistent across services? (case-sensitive — Level ≠ level)

  • Are label values normalized? (INFO, info, Info should all become info)

  • Is there a naming convention? (pick one: snake_case or camelCase — be consistent)


Evaluation Output Format

When auditing a label set, produce a report in the structure below.

Hard requirements before finalizing any audit report:

  1. Disclaimer (mandatory, first body section): Load references/disclaimer.md and paste its two paragraphs verbatim under a ### Disclaimer heading. An empty Disclaimer heading is a failed report — do not ship the audit until both paragraphs are present. Never paraphrase, summarize, or omit this text.

  2. Protected labels: Before recommending demote/drop for any label, load references/protected-labels.md. Never recommend dropping service_name, deployment_environment, or job when present — only value remediation. Include a Downstream dependency check covering alerts, dashboards, LBAC, and correlation.

  3. Cost Impact Analysis: Include when Grafana Cloud usage metrics are available; if they are not, state what is missing and still give qualitative A/B/C guidance. Load references/cost-impact.md and follow its Required report shape (scenario cards). Do not paste markdown tables or panel/query JSON into this section.

Report completion check: Before delivering, confirm (a) the output contains the substring Confidential Information of Raintank, Inc. immediately after ### Disclaimer, (b) Cost Impact Analysis uses scenario cards (A/B/C) with a Billing note opener and a bullet Measured baseline — not a scenario table and not panelId/targets JSON, and (c) no Action cell recommends dropping an allowlisted correlation label. If (a) is missing, paste from references/disclaimer.md and re-emit. If (b) fails, rewrite Cost Impact from references/cost-impact.md. If (c) fails, rewrite Actions per references/protected-labels.md.

## Loki Label Strategy Audit

### Disclaimer
[Paste BOTH paragraphs from references/disclaimer.md HERE — never leave this heading empty]

### Summary
[1-2 sentence overall assessment]

### Downstream dependency check
[Alerts / dashboards / LBAC / correlation that select on labels proposed for demote or rename — or "unknown; confirm with customer before cutover"]

### Label Analysis
| Label | Cardinality | Used in Queries? | Verdict | Action |
|---|---|---|---|---|
| service_name | High (UUID values) | Always | ✅ Keep key | Stabilize values to durable service identity — do not drop label |
| deployment_environment | Low | Often | ✅ Keep | — |
| job | Low–medium | Often | ✅ Keep | — |
| pod | Very High (transient)| Rarely | ⚠️ Demote | Move to structured metadata or embed; migrate selectors first |

### Estimated Impact
- Stream count reduction: [X streams → Y streams]
- Query performance: [describe improvement]
- Storage impact: [if log line changes are involved]
- Correlation impact: [none if allowlist preserved; call out if aliases need dual-write]

### Cost Impact Analysis
[Follow references/cost-impact.md Required report shape — do not invent a table]

**Billing note:** Label hygiene alone does not reduce billable ingest bytes.
Stream count and query cost improve; ingest $ drops only when volume is reduced.

**Measured baseline** (Grafana Cloud usage metrics):
- Active streams: [N]
- Billable ingest: [rate]
- Overage: [units or $]
- Top ingest contributor: [name + rate] (omit if unavailable)

**Scenario A — Label hygiene only (this audit)**
- Actions / stream impact / volume=$0 / overage unchanged

**Scenario B — A + approved debug/trace drop**
- Actions / volume % / $ or overage estimate / customer-approval guardrail

**Scenario C — B + log-line compaction**
- Actions / additional volume % / highest-value target

**Attribution gap:** [...]
**Caveats:** [...]

### Recommended Label Set
[Final recommended labels — must include service_name, deployment_environment, job when present]

### Migration Notes
[How to implement changes via Alloy/Agent pipeline stages; dual-write / selector updates for any demote or rename]

Every log source should consider these base labels — all low cardinality, high query value:

LabelPurpose
service_nameIdentifying the generating application (OTel service.name — required for Grafana Cloud correlation / App O11y)
deployment_environmentDeployment environment (OTel deployment.environment) — keep when present
jobCollector / OTel job (namespace/service.name pattern common on span metrics) — keep when present
app / serviceLegacy aliases only — prefer aligning to service_name; do not delete without a migration plan
envEnvironment shorthand (prod, staging, dev) when deployment_environment is absent
clusterMulti-cluster differentiation
regionGeographic region
levelLog severity — normalize to: info, warn, error, debug
team / squadOwnership (also useful for LBAC)
sourceLog origin type (file, k8s-events, journal, syslog, etc.)
classificationData sensitivity level — for LBAC policies

Always include allowlisted correlation labels in any label_keep list — see references/protected-labels.md.


Kubernetes Pod Logs

LabelDescription
service_nameStable service identity (OTel service.name) — keep; remediate UUID/ephemeral values
namespaceK8s namespace — delineates isolation boundaries
containerContainer name — low cardinality, differentiates log formats
workload{controller_kind}/{controller_name} e.g. ReplicaSet/payment-api — strongly recommended

Why workload beats app for K8s: Derived from {{controller_kind}}/{{controller_name}} — static values that never change like pod names do. Unlike app (which may aggregate multiple workload types), workload is precise and predictable. Users always know exactly what value to query. Still keep service_name for cross-signal correlation even when using workload.

Labels to demote in Kubernetes (not "never existed")

pod label ⚠️

  • Highly transient: pod names change on every restart/rollout

  • Very high cardinality: 5 pods × 2 containers = 10 streams; add pod → 10 × N streams

  • Users almost never query for a specific pod; they query for the workload

  • Solution: Use workload as the index label; store pod in structured metadata or embed in the log line. Migrate any alerts/dashboards that select on pod before demoting.

filename label (raw K8s path) ⚠️

  • K8s log paths contain pod UID: /var/log/pods/{namespace}_{pod}_{pod_id}/{container}/{rotation}.log

  • The pod_id component makes this unbounded

  • Solution: Normalize to /var/log/pods/{namespace}/{controller_name}/{container}.log or demote entirely after checking selectors

// Normalize K8s filename to remove pod UID
stage.replace {
 source = "filename"
 expression = "/var/log/pods/([^/]+)_[^_]+_[^/]+/([^/]+)/\\d+\\.log"
 replace = "/var/log/pods/$1/$2/current.log"
}

Host / VM / Bare Metal Labels

In addition to common labels, add:

LabelDescriptionNotes
instanceHostname of the machineCardinality = number of machines; acceptable for fixed infrastructure
filenameFull path to the file being tailedNormalize rotating filenames — strip date suffixes
// Remove date suffixes from rotating log file names
// /var/log/myapp/logfile-20230927.txt → /var/log/myapp/logfile.txt
stage.replace {
 source = "filename"
 expression = "-\\d{8}(\\.log|\\.txt)$"
 replace = "$1"
}

Journal Logs

When collecting via loki.source.journal, many labels are auto-discovered under __journal__*: boot_id, cap_effective, cmdline, comm, exe, gid, hostname, machine_id, pid, stream_id, systemd_cgroup, systemd_invocation_id, systemd_slice, systemd_unit, transport, uid

Almost all are high-cardinality. Keep instance (hostname) and unit (systemd_unit, e.g. nginx.service), plus any allowlisted correlation labels present on the stream (service_name, deployment_environment, job).

Drop other non-allowlisted high-cardinality journal labels (not platform keys):

loki.process "journal_labels" {
 forward_to = [...]
 stage.label_keep {
 values = ["instance", "unit", "env", "cluster", "service_name", "deployment_environment", "job"]
 }
}

Structured Metadata

Structured metadata attaches key-value pairs to log entries without making them index labels. The ideal home for high-cardinality values users occasionally need.

Requires: Loki 2.9+, Grafana Agent/Alloy. Enable via limits_config:

limits_config:
 allow_structured_metadata: true

Good candidates for structured metadata (not labels):

  • pod — K8s pod name

  • node — K8s worker node

  • version / image / tag

  • trace_id / user_id

  • process_id

  • restarted — pod restart timestamp

Query structured metadata at query time without a parser:

{service_name="payment-api"} | pod="payment-api-7f9d4b-xk2r9"

Embedding Metadata in Log Lines

When structured metadata isn't available, embed high-cardinality values into the log line rather than using them as labels.

Method 1: stage.template (append to log line)
loki.process "embed_pod" {
 forward_to = [...]

 // For JSON logs
 stage.match {
 selector = "{} |~ \"^\\s*\\{\""
 stage.replace {
 expression = "\\}$"
 replace = ""
 }
 stage.template {
 source = "log_line"
 template = "{{ .Entry }},\"_pod\":\"{{ .pod }}\"}"
 }
 }

 // For text logs
 stage.match {
 selector = "{} !~ \"^\\s*\\{\""
 stage.template {
 source = "log_line"
 template = "{{ .Entry }} _pod={{ .pod }}"
 }
 }

 stage.output { source = "log_line" }
}

Result: ts=... msg="..." _pod=agent-logs-cqhfk

Query by aggregate (normal use):

sum(count_over_time({workload="ReplicaSet/payment-api", level="error"}[1m]))

Query a specific pod (edge case debugging):

{workload="ReplicaSet/payment-api", level="error"} |= `_pod=payment-api-3`
Method 2: stage.pack (JSON envelope)
loki.process "pack_pod" {
 forward_to = [...]
 stage.pack {
 labels = ["pod"]
 ingest_timestamp = false
 }
}

Packed result: {"_entry": "original log line", "pod": "agent-logs-cqhfk"}

Unpack at query time:

{workload="ReplicaSet/payment-api", level="error"}
 |= `agent-logs-cqhfk`
 | unpack

Performance Bottleneck Diagnosis

When a user reports slow queries, identify where time is spent using Querier metrics.go logs.

Four Query Stages
StageMetricHigh Value MeansFix
Queuequeue_timeNot enough QueriersAdd Queriers or reduce parallelism
Indexchunk_refs_fetch_timeNeed more Index Gateway instancesScale index-gateways; check CPU
Storagestore_chunks_download_timeChunks too small OR storage bottleneckCheck avg chunk size: total_bytes / cache_chunk_req
Executionduration - chunk_refs_fetch_time - store_chunks_download_timeCPU-intensive regex, or too many tiny log linesReduce regex; add CPU; increase parallelism

Ideally, the majority of time is spent in Execution. If not, that indicates infrastructure or label design problems.

Checking Chunk Size
avg chunk size = total_bytes / cache_chunk_req

If the result is a few hundred bytes or kilobytes (instead of megabytes), chunks are too small. This means labels are over-splitting data into too many streams. Revisit cardinality — demote non-allowlisted high-card labels or stabilize protected-label values.

Problem: Query scans too many streams

  • Cause: High-cardinality labels exist but aren't specified in the query selector

  • Fix: Demote the label off the index after a migration check, or ensure queries always include it as a filter. Never demote allowlisted correlation labels — stabilize their values instead (protected-labels.md)

Problem: High post_filter_lines discard ratio (post_filter_lines << total_lines)

  • Cause: Insufficient label selectivity; query scans and discards most logs

  • Fix: Add labels matching user access patterns (level, workload, container, service_name)

Problem: Small chunks

  • Cause: Too many labels creating too many fine-grained streams

  • Fix: Demote high-cardinality non-allowlisted labels (e.g. pod) to consolidate streams; remediate protected-label values if they are the splitter

Query Optimization Quick Wins
  1. Add container or workload to narrow scope before line filters

  2. Add level label + always use it in queries (filters out 94%+ of logs when searching for errors)

  3. Demote pod off the index → reduces stream count by ~5× in typical K8s deployments (migrate selectors first)

  4. Replace regex line filters (|~) with exact filters (|=) where possible

  5. Keep service_name (and peers); if values are UUIDs/ephemeral, normalize to a stable identity — do not drop the key


Alloy / Agent Configuration Patterns

Normalize Log Level
loki.process "normalize_level" {
 forward_to = [...]
 stage.replace { source = "level"; expression = "(?i)I(nfo)?"; replace = "info" }
 stage.replace { source = "level"; expression = "(?i)W(arn(ing)?)?"; replace = "warn" }
 stage.replace { source = "level"; expression = "(?i)E(rr(or)?)?"; replace = "error" }
 stage.replace { source = "level"; expression = "(?i)D(ebug?)?"; replace = "debug" }
 stage.labels { values = { level = "" } }
}
Conditional Meta-Label Extraction
// Only extract when the relevant field is present — avoids unnecessary cardinality
loki.process "conditional_extraction" {
 forward_to = [...]
 stage.match {
 selector = "{app=\"loki\"} |= \"component\""
 stage.logfmt { mapping = { "component" = "" } }
 stage.labels { values = { component = "" } }
 }
}
Enforce Approved Label Set (always use as final stage)

Always include allowlisted correlation labels when present — never omit service_name, deployment_environment, or job from label_keep (protected-labels.md):

loki.process "enforce_labels" {
 forward_to = [loki.write.default.receiver]
 // ... other stages ...
 stage.label_keep {
 values = [
 "service_name", "deployment_environment", "job",
 "env", "cluster", "level", "namespace", "workload", "container",
 ]
 }
}
Soft Enforcement (inject "unknown" for missing labels)
stage.template {
 source = "team"
 template = "{{ if .Value }}{{ .Value }}{{ else }}unknown{{ end }}"
}
stage.labels { values = { team = "" } }

Log Line Optimization

Byte-level reductions (timestamps, ANSI, null JSON fields) for Scenario C savings — see references/log-line-optimization.md.


Security & LBAC

Grafana Enterprise Logs (GEL) supports Label-Based Access Control (LBAC). Any label can serve as an access control selector.

Best labels for LBAC:

  • classification — data sensitivity (public, restricted, confidential, top-secret)

  • source — controls which teams can see which log origins

  • team / squad — ownership-based access

  • env — environment-level restrictions

Static aggregate labels like owner=sysadmins or category=database are particularly effective: one label value gates access to many log files, rather than requiring a long allowlist of filenames or streams.


The 80/20 Rule

The most impactful improvements almost always come from these four changes:

  1. Demote pod off the index (structured metadata) — biggest stream reduction in K8s; migrate selectors first

  2. Add level as a label AND always specify it in queries — can eliminate 94%+ of scanned data when searching for errors

  3. Normalize label values — eliminates phantom duplicate streams from inconsistent casing; for service_name, stabilize UUID/ephemeral values (never drop the key)

  4. Normalize or demote filename in K8s — highly variable paths inflate stream count significantly

Focus on these before anything else. Never "fix" cardinality by dropping service_name, deployment_environment, or job.


Labels to Avoid — Quick Reference

LabelWhyAlternative
podTransient, high cardDemote: workload label + pod in structured metadata (migrate selectors)
user_idUnbounded — never valid as index labelKeep only in log content
request_id / trace_idUnbounded — never valid as index labelStructured metadata
filename (raw K8s path)Contains pod UIDNormalize or demote after selector check
Unnormalized levelINFO/info/Info = 3 streamsNormalize at collection time
UUID / ephemeral service_name valuesInflates streams; key is still requiredKeep key; map values to stable service identity
Any dynamically-named label keyCannot be boundedUse fixed keys with bounded values

Never drop: service_name, deployment_environment, job — see references/protected-labels.md.


Cost Impact Analysis

Label hygiene alone does not cut billable ingest bytes ($0 direct). Volume savings come from enabled stage.drop / log-line cleanup. Load references/cost-impact.md when writing the report section: use its scenario-card shape, cite scalar metrics (optional short panel ID / PromQL), and never paste the agent-only reference table or panel JSON into the customer report.

Files

LICENSE

                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright 2026 Grafana Labs

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Node.js

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
Grafana Labs
Publisher
Grafana Labs (Official)
Source
grafana/skills · skills/grafana-cloud/loki-label-analyzer · commit 8fb72a5
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Grafana Labs or Grafana Labs.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download loki-label-analyzer.zip