New Relic Agent Skill
Configure New Relic observability platform for infrastructure and application monitoring. Set up APM agents, create dashboards, configure alerts, and implement distributed tracing. Use when implementing full-stack observability with New Relic One.
Install
one command, takes just this skill from the repositorynpx skills add https://github.com/BagelHole/DevOps-Security-Agent-Skills --skill new-relicThe instruction itself
33 sections, as written by the authorNew Relic
Monitor applications and infrastructure with New Relic's observability platform.
When to Use This Skill
Use this skill when:
- Implementing full-stack observability
- Setting up APM for applications
- Monitoring infrastructure health
- Creating custom dashboards and alerts
- Implementing distributed tracing
Prerequisites
- New Relic account and license key
- Application access for APM agents
- Infrastructure access for host agents
Infrastructure Agent
Linux Installation
# Add repository and install
curl -Ls https://download.newrelic.com/install/newrelic-cli/scripts/install.sh | bash
# Configure license key
sudo NEW_RELIC_API_KEY=<YOUR_API_KEY> NEW_RELIC_ACCOUNT_ID=<ACCOUNT_ID> /usr/local/bin/newrelic install
# Or manual configuration
echo "license_key: YOUR_LICENSE_KEY" | sudo tee -a /etc/newrelic-infra.yml
sudo systemctl start newrelic-infra
Docker
# docker-compose.yml
version: '3.8'
services:
newrelic-infra:
image: newrelic/infrastructure:latest
cap_add:
- SYS_PTRACE
privileged: true
pid: "host"
network_mode: "host"
environment:
- NRIA_LICENSE_KEY=${NEW_RELIC_LICENSE_KEY}
- NRIA_DISPLAY_NAME=docker-host
volumes:
- /:/host:ro
- /var/run/docker.sock:/var/run/docker.sock
Kubernetes
# Using Helm
helm repo add newrelic https://helm-charts.newrelic.com
helm install newrelic-bundle newrelic/nri-bundle \
--namespace newrelic \
--create-namespace \
--set global.licenseKey=${NEW_RELIC_LICENSE_KEY} \
--set global.cluster=my-cluster \
--set newrelic-infrastructure.privileged=true \
--set ksm.enabled=true \
--set kubeEvents.enabled=true \
--set logging.enabled=true
APM Agents
Node.js
// At the very start of your application
require('newrelic');
// newrelic.js configuration
exports.config = {
app_name: ['My Application'],
license_key: process.env.NEW_RELIC_LICENSE_KEY,
distributed_tracing: {
enabled: true
},
logging: {
level: 'info'
},
error_collector: {
enabled: true,
ignore_status_codes: [404]
},
transaction_tracer: {
enabled: true,
transaction_threshold: 'apdex_f',
record_sql: 'obfuscated'
}
};
# Install agent
npm install newrelic
# Run application
NEW_RELIC_LICENSE_KEY=xxx node -r newrelic app.js
Python
# newrelic.ini
[newrelic]
license_key = YOUR_LICENSE_KEY
app_name = My Application
distributed_tracing.enabled = true
transaction_tracer.enabled = true
error_collector.enabled = true
browser_monitoring.auto_instrument = true
# Install agent
pip install newrelic
# Generate config file
newrelic-admin generate-config YOUR_LICENSE_KEY newrelic.ini
# Run application
NEW_RELIC_CONFIG_FILE=newrelic.ini newrelic-admin run-program python app.py
# Or with gunicorn
NEW_RELIC_CONFIG_FILE=newrelic.ini newrelic-admin run-program gunicorn app:app
Java
# Download agent
curl -O https://download.newrelic.com/newrelic/java-agent/newrelic-agent/current/newrelic-java.zip
unzip newrelic-java.zip
# Configure newrelic.yml
# license_key: YOUR_LICENSE_KEY
# app_name: My Application
# Run with agent
java -javaagent:/path/to/newrelic.jar -jar myapp.jar
Go
package main
import (
"github.com/newrelic/go-agent/v3/newrelic"
"net/http"
)
func main() {
app, err := newrelic.NewApplication(
newrelic.ConfigAppName("My Application"),
newrelic.ConfigLicense("YOUR_LICENSE_KEY"),
newrelic.ConfigDistributedTracerEnabled(true),
)
if err != nil {
panic(err)
}
http.HandleFunc(newrelic.WrapHandleFunc(app, "/", indexHandler))
http.ListenAndServe(":8080", nil)
}
func indexHandler(w http.ResponseWriter, r *http.Request) {
txn := newrelic.FromContext(r.Context())
txn.AddAttribute("user_id", "12345")
w.Write([]byte("Hello, World!"))
}
Custom Instrumentation
Custom Events
import newrelic.agent
# Record custom event
newrelic.agent.record_custom_event('OrderPlaced', {
'order_id': '12345',
'amount': 99.99,
'customer_id': 'cust_001'
})
Custom Metrics
import newrelic.agent
# Record custom metric
newrelic.agent.record_custom_metric('Custom/OrderValue', 99.99)
# With attributes
newrelic.agent.record_custom_metric('Custom/ProcessingTime',
processing_time,
{'unit': 'milliseconds'}
)
Custom Spans
import newrelic.agent
@newrelic.agent.function_trace(name='process_payment')
def process_payment(order_id, amount):
# This creates a custom span in the trace
pass
# Manual span creation
with newrelic.agent.FunctionTrace(name='custom_operation'):
# Traced code
pass
NRQL Queries
Basic Queries
-- Transaction throughput
SELECT rate(count(*), 1 minute) FROM Transaction
WHERE appName = 'My Application'
SINCE 1 hour ago
-- Average response time
SELECT average(duration) FROM Transaction
WHERE appName = 'My Application'
SINCE 1 hour ago
-- Error rate
SELECT percentage(count(*), WHERE error IS true) FROM Transaction
WHERE appName = 'My Application'
SINCE 1 hour ago
-- Apdex score
SELECT apdex(duration, t: 0.5) FROM Transaction
WHERE appName = 'My Application'
SINCE 1 hour ago
Advanced Queries
-- Slowest transactions
SELECT average(duration) FROM Transaction
WHERE appName = 'My Application'
FACET name
SINCE 1 hour ago
ORDER BY average(duration) DESC
LIMIT 10
-- Error breakdown
SELECT count(*) FROM TransactionError
WHERE appName = 'My Application'
FACET error.class
SINCE 1 hour ago
-- Percentile response times
SELECT percentile(duration, 50, 90, 95, 99) FROM Transaction
WHERE appName = 'My Application'
SINCE 1 hour ago TIMESERIES
-- Custom event analysis
SELECT average(amount), count(*) FROM OrderPlaced
FACET customer_id
SINCE 1 day ago
Dashboards
Dashboard JSON
{
"name": "Application Dashboard",
"pages": [
{
"name": "Overview",
"widgets": [
{
"title": "Throughput",
"visualization": {"id": "viz.line"},
"configuration": {
"nrqlQueries": [
{
"accountId": 12345,
"query": "SELECT rate(count(*), 1 minute) FROM Transaction WHERE appName = 'My Application' SINCE 1 hour ago TIMESERIES"
}
]
}
},
{
"title": "Error Rate",
"visualization": {"id": "viz.billboard"},
"configuration": {
"nrqlQueries": [
{
"accountId": 12345,
"query": "SELECT percentage(count(*), WHERE error IS true) FROM Transaction WHERE appName = 'My Application' SINCE 1 hour ago"
}
]
}
}
]
}
]
}
Alerts
Alert Condition (NRQL)
{
"name": "High Error Rate",
"type": "static",
"nrql": {
"query": "SELECT percentage(count(*), WHERE error IS true) FROM Transaction WHERE appName = 'My Application'"
},
"valueFunction": "single_value",
"terms": [
{
"threshold": 5,
"thresholdOccurrences": "all",
"thresholdDuration": 300,
"operator": "above",
"priority": "critical"
},
{
"threshold": 2,
"thresholdOccurrences": "all",
"thresholdDuration": 300,
"operator": "above",
"priority": "warning"
}
]
}
Alert Policy
{
"name": "Application Alerts",
"incident_preference": "PER_CONDITION_AND_TARGET",
"conditions": [
{
"name": "High Response Time",
"type": "apm_app_metric",
"entities": ["My Application"],
"metric": "response_time_web",
"condition_scope": "application",
"terms": [
{
"duration": "5",
"operator": "above",
"threshold": "1",
"priority": "critical"
}
]
}
]
}
Logs in Context
Python Configuration
# newrelic.ini
[newrelic]
application_logging.enabled = true
application_logging.forwarding.enabled = true
application_logging.metrics.enabled = true
application_logging.local_decorating.enabled = true
Log Forwarding
# newrelic-infra.yml
log:
- name: application-logs
file: /var/log/myapp/*.log
attributes:
service: myapp
environment: production
Common Issues
Issue: No Data Appearing
Problem: Agent not reporting to New Relic
Solution: Verify license key, check network connectivity, review agent logs
Issue: Missing Transactions
Problem: Some transactions not captured
Solution: Check instrumentation coverage, verify framework support
Issue: High Overhead
Problem: APM agent impacting performance
Solution: Adjust sampling rate, disable unnecessary features
Best Practices
- Use meaningful application names
- Implement distributed tracing across services
- Set up service maps for dependency visualization
- Configure appropriate alert thresholds
- Use custom attributes for business context
- Implement logs in context for correlation
- Set up workloads for service grouping
- Regular review of unused dashboards and alerts
Related Skills
- datadog - Alternative monitoring platform
- prometheus-grafana - Open source monitoring
- alerting-oncall - Alert management
Other skills for the same job
different authors, same section of the catalogue
Assess Kubernetes workloads and cluster configuration for AKS Automatic compatibility. Identifies incompatibilities, generates fixes, and guides migration from AKS Standard to AKS Automatic. WHEN: migrate to AKS Automatic, check AKS Automatic readiness, validate manifests for Automatic, assess cluster for Automatic compatibility, fix deployment for Automatic compatibility, identify AKS Automatic migration blockers, is my cluster ready for AKS Automatic.
Discovers available Azure OpenAI model capacity across regions and projects. Analyzes quota limits, compares availability, and recommends optimal deployment locations based on capacity requirements. USE FOR: find capacity, check quota, where can I deploy, capacity discovery, best region for capacity, multi-project capacity search, quota analysis, model availability, region comparison, check TPM availability. DO NOT USE FOR: actual deployment (hand off to preset or customize after discovery), quota increase requests (direct user to Azure Portal), listing existing deployments.
Interactive guided deployment flow for Azure OpenAI models with full customization control. Step-by-step selection of model version, SKU (GlobalStandard/Standard/ProvisionedManaged), capacity, RAI policy (content filter), and advanced options (dynamic quota, priority processing, spillover). USE FOR: custom deployment, customize model deployment, choose version, select SKU, set capacity, configure content filter, RAI policy, deployment options, detailed deployment, advanced deployment, PTU deployment, provisioned throughput. DO NOT USE FOR: quick deployment to optimal region (use preset).
Unified Azure OpenAI model deployment skill with intelligent intent-based routing. Handles quick preset deployments, fully customized deployments (version/SKU/capacity/RAI policy), and capacity discovery across regions and projects. USE FOR: deploy model, deploy gpt, create deployment, model deployment, deploy openai model, set up model, provision model, find capacity, check model availability, where can I deploy, best region for model, capacity analysis. DO NOT USE FOR: listing existing deployments (use foundry_models_deployments_list MCP tool), deleting deployments, agent creation (use agent/create), project creation (use project/create).
Intelligently deploys Azure OpenAI models to optimal regions by analyzing capacity across all available regions. Automatically checks current region first and shows alternatives if needed. USE FOR: quick deployment, optimal region, best region, automatic region selection, fast setup, multi-region capacity check, high availability deployment, deploy to best location. DO NOT USE FOR: custom SKU selection (use customize), specific version selection (use customize), custom capacity configuration (use customize), PTU deployments (use customize).
This skill should be used when working with LaminDB, an open-source data framework for biology that makes data queryable, traceable, reproducible, and FAIR. Use when managing biological datasets (scRNA-seq, spatial, flow cytometry, etc.), tracking computational workflows, curating and validating data with biological ontologies, building data lakehouses, or ensuring data lineage and reproducibility in biological research. Covers data management, annotation, ontologies (genes, cell types, diseases, tissues), schema validation, integrations with workflow managers (Nextflow, Snakemake) and MLOps platforms (W&B, MLflow), and deployment strategies.
Latch platform for bioinformatics workflows. Build pipelines with Latch SDK, @workflow/@task decorators, deploy serverless workflows, LatchFile/LatchDir, Nextflow/Snakemake integration.
Run Python code in the cloud with serverless containers, GPUs, and autoscaling. Use when deploying ML models, running batch processing jobs, scheduling compute-intensive tasks, or serving APIs that require GPU acceleration or dynamic scaling.
How to use it
Take bagelhole/new-relic from the repository into ~/.claude/skills for personal
use, or into .claude/skills inside a project.
The agent identifies a skill by the name field in its header. Two skills with the
same name cannot sit side by side — one of them will be ignored.
The instructions reference pip, npm.
Without those the skill loads but fails at the first command.