Zero Day Exploit

Introduction

As engineering workflows shift toward the command line and agentic tools like Cursor and Claude Code become more prevalent, the way you observe and respond to system issues must adapt. The gcx CLI tool (Grafana Cloud CLI) brings observability directly into your terminal—and into your agentic coding environment—eliminating context switching and bridging the visibility gap for AI agents. This guide walks you through setting up and using gcx to achieve full observability for your services, from instrumentation to alerting and SLOs, all from the command line.

What You Need

• A Grafana Cloud account (free tier available)
• A terminal with internet access
• Basic familiarity with command-line interfaces and JSON/YAML
• (Optional) An agentic coding tool like Cursor or Claude Code
• A target service you want to observe (e.g., a microservice, frontend, or Kubernetes workload)

Step-by-Step Guide

Step 1: Install the gcx CLI

Download and install the gcx tool from the Grafana Cloud documentation. Use your package manager or the provided script. Verify installation by running:

gcx version

Authenticate with your Grafana Cloud stack using:

gcx auth login

Follow the browser-based OAuth flow to connect your CLI to your Grafana Cloud instance.

Step 2: Point Your Agent at a Service

Tell your agent (or yourself) which service to observe. For a new service without any instrumentation, use:

gcx init --service my-service

This creates a configuration context for that service. gcx treats a greenfield service—no instrumentation, alerts, or SLOs—as a starting point, not a blocker. Your agent can now reference this context.

Step 3: Instrument the Codebase with OpenTelemetry

Automatically wire OpenTelemetry into your code:

gcx instrument --language python --service my-service

Replace python with your service's language (e.g., go, node, java). This command generates and inserts the necessary instrumentation code into your source files. The gcx tool uses Grafana's Instrumentation Hub to apply best-practice configurations.

Alternatively, point your agent at the service and ask it to "bring the service up to standard." The agent will use gcx primitives to perform instrumentation automatically.

Step 4: Validate That Data Is Flowing

After instrumentation, confirm that metrics, logs, and traces reach your Grafana Cloud stack:

gcx validate --service my-service

This checks whether data is arriving in the correct metric, log, and trace backends. If you see gaps, the tool provides actionable feedback—for example, missing environment variables or wrong endpoint URLs. Use your agent to fix these issues based on the validation output.

Step 5: Set Up Alerting and SLOs

Generate alert rules from the signals your service actually emits:

gcx alerts create --service my-service --rules quorum

This scans your metrics and traces to suggest meaningful alert thresholds. Next, define a Service Level Objective (SLO) against a real latency or availability indicator:

gcx slo define --service my-service --metric latency95 --target 99.9 --window 30d

Push the SLO live with gcx slo push. Your agent can read the current SLO status and alert configurations to make code changes that directly improve reliability.

Step 6: Create Synthetic Checks

Proactively monitor your endpoints before users report outages. Create a synthetic probe:

gcx synthetic create --url https://my-service.example.com/api/health --interval 60s --regions us-west,eu-west

This sets up synthetic monitoring that runs from multiple global locations. The check results appear in your Grafana Cloud dashboards and can trigger alerts. gcx also supports browser-level synthetics for frontend applications.

Step 7: Manage Dashboards and Resources as Code

Pull existing dashboards, alerts, SLOs, and checks as files:

gcx export --service my-service --dir ./observability-as-code

Edit these files locally—using your agent to refine thresholds, change dashboard panels, or optimize alert logic. Then push your changes back:

gcx apply --dir ./observability-as-code

Everything is version-controlled and repeatable. Your agent can reason about production state by reading the gcx configuration files.

Step 8: Use Deep Links to Grafana Cloud

When a human needs to investigate an anomaly, generate a deep link directly from the terminal:

gcx link --service my-service --dashboard latency

This opens your browser to the exact Grafana Cloud dashboard for that service. The deep link includes helpful context—time range, filters, and related alerts—so you can jump straight into debugging without manual navigation.

Tips for Success

• Leverage your agent: Give your AI coding assistant access to gcx commands. It can automatically instrument, validate, and tune alerts based on real production data—not just pattern matching on source files.
• Iterate incrementally: Start with one service. Once you're comfortable with the flow, scale to more services. Use gcx to template and replicate configurations across your stack.
• Keep everything as code: Store exported configurations in a Git repository. This enables code reviews, rollbacks, and audit trails for your observability setup.
• Validate early, validate often: After each change (new alert, SLO update, or instrumentation tweak), run gcx validate to catch misconfigurations before they affect production.
• Combine with other tools: Use gcx alongside your existing CI/CD pipelines. For example, run gcx validate in a post-deploy step to ensure deployment hasn't broken observability.
• Explore the public preview: As of this writing, gcx is in public preview. Provide feedback to Grafana Labs to shape future features. Expect breaking changes until GA.

By following these steps, you'll transform your terminal into a full observability control center—for both human engineers and AI agents. No more context switching, no more blind spots. Just faster incident resolution and data-driven code generation.