New Relic

Overview

New Relic is an observability platform providing tools for monitoring, managing, and optimizing software applications and infrastructure. Established in 2008, the platform integrates various monitoring capabilities, including Application Performance Monitoring (APM), infrastructure monitoring, browser monitoring, and mobile monitoring, into a single interface. The objective is to provide development and operations teams with a unified view of their systems, facilitating performance analysis, error detection, and incident response.

The platform is designed for environments requiring comprehensive visibility across distributed systems and microservices architectures. It supports a range of programming languages and frameworks through its Software Development Kits (SDKs) for Java, Node.js, Python, Ruby, .NET, Go, and PHP. New Relic aims to assist organizations in identifying bottlenecks, understanding user experience, and managing the health of their entire software stack from a single pane of glass.

New Relic's offerings extend to log management, synthetic monitoring, and security features like vulnerability management. It focuses on providing real-time data and analytics to help teams understand application behavior in production, diagnose issues, and improve overall system reliability. The platform's capabilities are particularly suited for large enterprise environments that manage complex and interconnected services, where proactive incident response and performance optimization are critical to business operations. Its compliance standards, including GDPR compliance and HIPAA compliance, also position it for regulated industries.

Key features

• APM (Application Performance Monitoring): Provides detailed insights into application health, transaction traces, error rates, and response times for various programming languages.
• Infrastructure Monitoring: Collects metrics from hosts, containers, and services to monitor server performance, resource utilization, and system health.
• Browser Monitoring: Tracks real user experience (RUM) metrics, including page load times, JavaScript errors, and AJAX performance from the end-user perspective.
• Mobile Monitoring: Monitors the performance and health of native mobile applications, capturing crash reports, network performance, and user interaction data.
• Synthetics Monitoring: Proactively tests application availability and performance from various global locations using simulated user journeys.
• Logs: Centralizes log data from across the stack, allowing for correlation with other telemetry data to aid in troubleshooting and analysis.
• Errors Inbox: Aggregates and prioritizes application errors, providing context and tools for debugging and resolution.
• Database Monitoring: Offers visibility into database performance, query analysis, and capacity planning for various database technologies.
• Network Performance Monitoring: Monitors network flow data to identify and troubleshoot network-related issues affecting application performance.
• Security (New Relic Vulnerability Management): Detects and prioritizes software vulnerabilities within the application stack.

Pricing

New Relic employs a usage-based pricing model, primarily calculated by the amount of data ingested and the number of users. A free tier is available, offering full platform access for one Free User and up to 100 GB of data ingest per month.

For more detailed information on data ingest rates and specific feature sets per user type, refer to the New Relic pricing page.

Common integrations

• Amazon Web Services (AWS): Monitor AWS services like EC2, Lambda, S3 directly from New Relic. Refer to New Relic's AWS integrations documentation.
• Microsoft Azure: Integrate with Azure Monitor to collect metrics and logs from Azure resources. More details are available in the Azure integrations guide.
• Google Cloud Platform (GCP): Connect to GCP services to gather performance data. See the GCP integrations documentation.
• Kubernetes: Monitor Kubernetes clusters, pods, and deployments. The Kubernetes integration overview provides setup instructions.
• Docker: Collect metrics from Docker containers and hosts. The Docker integration documentation outlines the process.
• Prometheus: Ingest metrics from Prometheus exporters. Refer to New Relic's Prometheus integration guide.
• Grafana: Display New Relic data within Grafana dashboards using the New Relic data source plugin.
• Slack: Send alerts and notifications to Slack channels for immediate team awareness.
• PagerDuty: Integrate with PagerDuty for incident management and on-call rotations.

Alternatives

• Dynatrace: Offers an AI-powered observability platform with automated full-stack monitoring and application security capabilities.
• AppDynamics: Specializes in application performance monitoring with a focus on business transaction monitoring and user experience. For a comparison of APM tools, refer to AppDynamics' comparison.
• Datadog: Provides a monitoring and security platform for cloud applications, offering infrastructure monitoring, log management, and APM.
• Splunk: A data platform known for security information and event management (SIEM), offering observability solutions through Splunk Observability Cloud.
• Prometheus: An open-source monitoring system with a dimensional data model, flexible query language, and alerting capabilities, often paired with Grafana for visualization.

Getting started

To begin monitoring a Python application with New Relic, you typically install the New Relic Python agent. This example demonstrates a basic Flask application integration.

# First, install the New Relic Python agent
# pip install newrelic

# newrelic.ini configuration file (example content)
# [newrelic]
# app_name = My Python App
# license_key = YOUR_NEW_RELIC_LICENSE_KEY
# log_level = info

import os
from flask import Flask

# Import the New Relic agent and wrap the Flask app
# Ensure NEW_RELIC_CONFIG_FILE points to your newrelic.ini
os.environ['NEW_RELIC_CONFIG_FILE'] = 'newrelic.ini'

# It's crucial to import and initialize the agent BEFORE other application imports
# if you want to instrument everything from the start.
# For a simple script, you might run it via `newrelic-admin run-program python your_app.py`
# For WSGI apps, you will configure your WSGI server (e.g., Gunicorn) to use newrelic.agent.WSGIApplicationWrapper

# For demonstration, we'll manually wrap a simple app here.
# In a real Flask app, you'd typically integrate with a WSGI server or use a more advanced method.

app = Flask(__name__)

# A simple route
@app.route('/')
def hello_world():
    return 'Hello from New Relic monitored Flask app!'

@app.route('/slow')
def slow_endpoint():
    import time
    time.sleep(0.5) # Simulate some work
    return 'This was a slow request!'

if __name__ == '__main__':
    # To run this with New Relic in a development environment:
    # 1. Ensure newrelic.ini is configured with your license key.
    # 2. Run: newrelic-admin run-program python your_app.py
    # For a production WSGI setup, consult New Relic's Python agent documentation.
    print("Starting Flask app. Ensure you run this via 'newrelic-admin run-program python your_app.py' or configure your WSGI server.")
    # The app.run() below might not be fully instrumented without newrelic-admin wrapper
    # app.run(debug=True)

To run this example with New Relic, you would typically execute your application via the newrelic-admin run-program command, ensuring your newrelic.ini file is correctly configured with your license key and application name. For a Flask application deployed with a WSGI server like Gunicorn or uWSGI, the New Relic agent is integrated by wrapping the WSGI application directly. Detailed instructions for various deployment scenarios are available in the New Relic Python agent installation guide.