Menu
Use pup CLI for immediate Datadog operations or generate code for integration into applications
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Basé sur la classification professionnelle SOC
| name | dd-code-generation |
| description | Use pup CLI for immediate Datadog operations or generate code for integration into applications |
| tags | ["pup","cli","code-generation","typescript","python","java","go","rust"] |
This skill helps users interact with Datadog through two complementary approaches:
pup CLI toolUse this skill when the user:
The pup CLI is a Go-based command-line wrapper for Datadog APIs. It provides:
# OAuth2 (preferred)
pup auth login
# API Keys (fallback)
export DD_API_KEY="your-api-key"
export DD_APP_KEY="your-app-key"
export DD_SITE="datadoghq.com"
pup <domain> <action> [options]
pup <domain> <subgroup> <action> [options]
# Examples
pup monitors list --tag="env:prod"
pup logs search --query="status:error" --from="1h"
pup metrics query --query="avg:system.cpu.user{*}" --from="1h"
See pup --help for complete command reference.
When users want immediate results, execute pup commands:
# Query metrics
pup metrics query --query="avg:system.cpu.user{*}" --from="1h" --to="now"
# Search logs
pup logs search --query="status:error service:api" --from="30m"
# List monitors
pup monitors list --tag="team:backend"
# Get dashboard
pup dashboards get abc-123-def
When users want to integrate into their application, provide code examples using official Datadog API clients.
import { client, v2 } from '@datadog/datadog-api-client';
// Configure authentication
const configuration = client.createConfiguration({
authMethods: {
apiKeyAuth: process.env.DD_API_KEY || '',
appKeyAuth: process.env.DD_APP_KEY || '',
},
});
// Query metrics
async function queryMetrics() {
const apiInstance = new v2.MetricsApi(configuration);
try {
const params: v2.MetricsApiQueryTimeseriesDataRequest = {
body: {
data: {
type: 'timeseries_request',
attributes: {
formulas: [{
formula: 'query1'
}],
queries: [{
name: 'query1',
dataSource: 'metrics',
query: 'avg:system.cpu.user{*}'
}],
from: Date.now() - 3600000, // 1 hour ago
to: Date.now()
}
}
}
};
const result = await apiInstance.queryTimeseriesData(params);
console.log(JSON.stringify(result, null, 2));
} catch (error) {
console.error('Error:', error);
}
}
queryMetrics();
Installation: npm install @datadog/datadog-api-client
#!/usr/bin/env python3
import os
from datetime import datetime, timedelta
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.metrics_api import MetricsApi
from datadog_api_client.v2.model.timeseries_formula_request import TimeseriesFormulaRequest
from datadog_api_client.v2.model.timeseries_formula_query_request import TimeseriesFormulaQueryRequest
from datadog_api_client.v2.model.timeseries_formula_request_attributes import TimeseriesFormulaRequestAttributes
from datadog_api_client.v2.model.timeseries_formula_request_type import TimeseriesFormulaRequestType
def configure_datadog():
configuration = Configuration()
configuration.api_key['apiKeyAuth'] = os.getenv('DD_API_KEY')
configuration.api_key['appKeyAuth'] = os.getenv('DD_APP_KEY')
configuration.server_variables['site'] = os.getenv('DD_SITE', 'datadoghq.com')
return configuration
def query_metrics():
configuration = configure_datadog()
with ApiClient(configuration) as api_client:
api_instance = MetricsApi(api_client)
# Query parameters
now = int(datetime.now().timestamp())
one_hour_ago = int((datetime.now() - timedelta(hours=1)).timestamp())
body = TimeseriesFormulaRequest(
data=TimeseriesFormulaQueryRequest(
type=TimeseriesFormulaRequestType.TIMESERIES_REQUEST,
attributes=TimeseriesFormulaRequestAttributes(
formulas=[{"formula": "query1"}],
queries=[{
"name": "query1",
"data_source": "metrics",
"query": "avg:system.cpu.user{*}"
}],
_from=one_hour_ago,
to=now
)
)
)
try:
result = api_instance.query_timeseries_data(body=body)
print(result)
except Exception as e:
print(f"Error: {e}")
if __name__ == "__main__":
query_metrics()
Installation: pip install datadog-api-client
package com.datadog.api.example;
import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.MetricsApi;
import com.datadog.api.client.v2.model.*;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Collections;
public class MetricsQueryExample {
public static void main(String[] args) {
// Validate environment variables
String apiKey = System.getenv("DD_API_KEY");
String appKey = System.getenv("DD_APP_KEY");
String site = System.getenv().getOrDefault("DD_SITE", "datadoghq.com");
if (apiKey == null || appKey == null) {
System.err.println("Error: DD_API_KEY and DD_APP_KEY must be set");
System.exit(1);
}
// Configure API client
ApiClient apiClient = ApiClient.getDefaultApiClient();
apiClient.setServerVariableValue("site", site);
apiClient.configureApiKeys(Collections.singletonMap("apiKeyAuth", apiKey));
apiClient.configureApiKeys(Collections.singletonMap("appKeyAuth", appKey));
try {
queryMetrics(apiClient);
} catch (ApiException e) {
System.err.println("API Error: " + e.getMessage());
e.printStackTrace();
}
}
private static void queryMetrics(ApiClient apiClient) throws ApiException {
MetricsApi apiInstance = new MetricsApi(apiClient);
// Time range: last hour
long now = Instant.now().getEpochSecond();
long oneHourAgo = Instant.now().minus(1, ChronoUnit.HOURS).getEpochSecond();
// Build query
TimeseriesFormulaQueryRequest query = new TimeseriesFormulaQueryRequest()
.type(TimeseriesFormulaRequestType.TIMESERIES_REQUEST)
.attributes(new TimeseriesFormulaRequestAttributes()
.formulas(Collections.singletonList(new QueryFormula().formula("query1")))
.queries(Collections.singletonList(
new MetricsTimeseriesQuery()
.name("query1")
.dataSource(MetricsDataSource.METRICS)
.query("avg:system.cpu.user{*}")
))
.from(oneHourAgo)
.to(now)
);
TimeseriesFormulaRequest body = new TimeseriesFormulaRequest().data(query);
// Execute query
TimeseriesFormulaResponse result = apiInstance.queryTimeseriesData(body);
System.out.println(result);
}
}
Installation: Add to pom.xml:
<dependency>
<groupId>com.datadoghq</groupId>
<artifactId>datadog-api-client</artifactId>
<version>2.30.0</version>
</dependency>
package main
import (
"context"
"encoding/json"
"fmt"
"os"
"time"
datadog "github.com/DataDog/datadog-api-client-go/v2/api/datadog"
"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)
func main() {
// Validate environment variables
apiKey := os.Getenv("DD_API_KEY")
appKey := os.Getenv("DD_APP_KEY")
if apiKey == "" || appKey == "" {
fmt.Println("Error: DD_API_KEY and DD_APP_KEY must be set")
os.Exit(1)
}
// Configure API client
ctx := context.WithValue(
context.Background(),
datadog.ContextAPIKeys,
map[string]datadog.APIKey{
"apiKeyAuth": {Key: apiKey},
"appKeyAuth": {Key: appKey},
},
)
configuration := datadog.NewConfiguration()
apiClient := datadog.NewAPIClient(configuration)
api := datadogV2.NewMetricsApi(apiClient)
// Time range: last hour
now := time.Now().Unix()
oneHourAgo := time.Now().Add(-1 * time.Hour).Unix()
// Build query
body := datadogV2.TimeseriesFormulaRequest{
Data: datadogV2.TimeseriesFormulaQueryRequest{
Type: datadogV2.TIMESERIESFORMULAREQUESTTYPE_TIMESERIES_REQUEST,
Attributes: datadogV2.TimeseriesFormulaRequestAttributes{
Formulas: []datadogV2.QueryFormula{
{Formula: "query1"},
},
Queries: []datadogV2.TimeseriesQuery{
datadogV2.MetricsTimeseriesQuery{
Name: datadog.PtrString("query1"),
DataSource: datadogV2.METRICSDATASOURCE_METRICS,
Query: "avg:system.cpu.user{*}",
},
},
From: oneHourAgo,
To: now,
},
},
}
// Execute query
result, _, err := api.QueryTimeseriesData(ctx, body)
if err != nil {
fmt.Printf("Error: %v\n", err)
os.Exit(1)
}
jsonData, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(jsonData))
}
Installation: go get github.com/DataDog/datadog-api-client-go/v2
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_metrics::MetricsAPI;
use datadog_api_client::datadogV2::model::*;
use std::collections::HashMap;
#[tokio::main]
async fn main() {
// Validate environment variables
let api_key = std::env::var("DD_API_KEY")
.expect("DD_API_KEY must be set");
let app_key = std::env::var("DD_APP_KEY")
.expect("DD_APP_KEY must be set");
// Configure API client
let mut configuration = datadog::Configuration::new();
configuration.api_key = Some(HashMap::from([
("apiKeyAuth".to_string(), api_key),
("appKeyAuth".to_string(), app_key),
]));
let api = MetricsAPI::with_config(configuration);
// Time range: last hour
let now = chrono::Utc::now().timestamp();
let one_hour_ago = (chrono::Utc::now() - chrono::Duration::hours(1)).timestamp();
// Build query
let body = TimeseriesFormulaRequest::new(
TimeseriesFormulaQueryRequest::new(
TimeseriesFormulaRequestAttributes::new(
vec![QueryFormula::new("query1".to_string())],
one_hour_ago,
vec![
TimeseriesQuery::MetricsTimeseriesQuery(Box::new(
MetricsTimeseriesQuery::new(
MetricsDataSource::METRICS,
"avg:system.cpu.user{*}".to_string(),
)
.name("query1".to_string())
))
],
now,
),
TimeseriesFormulaRequestType::TIMESERIES_REQUEST,
)
);
// Execute query
match api.query_timeseries_data(body).await {
Ok(result) => {
println!("{:#?}", result);
}
Err(err) => {
eprintln!("Error: {}", err);
}
}
}
Installation: Add to Cargo.toml:
[dependencies]
datadog-api-client = "0.3"
tokio = { version = "1", features = ["full"] }
chrono = "0.4"
User: "Show me CPU usage for the last hour"
Response:
# Execute pup command for immediate results
pup metrics query --query="avg:system.cpu.user{*}" --from="1h" --to="now" --output=table
User: "Generate Python code to query error logs"
Response:
Here's Python code to query error logs using the Datadog API client:
[Provide Python code example using datadog-api-client]
To use this code:
1. Save to a file: `query_logs.py`
2. Install: `pip install datadog-api-client`
3. Set environment variables: `export DD_API_KEY="..." DD_APP_KEY="..."`
4. Run: `python query_logs.py`
For immediate results without writing code, you can also use:
pup logs search --query="status:error" --from="1h"
User: "List all production monitors"
Response:
# Using pup CLI
pup monitors list --tag="env:production" --output=table
# Or generate code for your application (specify language: typescript, python, java, go, rust)
This skill works with all 46 domain agents in the plugin:
pup --helpAPM - traces, services, dependencies, performance analysis.
Log management - search, pipelines, archives, and cost control.
Monitor management - create, update, mute, and alerting best practices.
Datadog CLI (pup). OAuth2 auth with token refresh.
Review a PR in shawnrice's style — educational, non-blocking, focused on readability, functional patterns, and teaching the "why". Accepts a GitHub URL or PR number (optionally prefixed with #).
Toggle peon-ping sound notifications on/off. Use when user wants to mute, unmute, pause, or resume peon sounds during a Claude Code session.