Application Performance Management (APM) with New Relic Training Course

Introduction to Application Performance Monitoring

• The role of Application Performance Management (APM) in modern application operations
• The interplay between application performance, availability, reliability, and customer experience
• Essential performance indicators and service-level objectives
• Common causes of application performance degradation
• The application monitoring lifecycle: observation, analysis, diagnosis, remediation, and optimization
• The contribution of New Relic to full-stack observability

New Relic Features and Architecture

• Overview of the New Relic platform and its primary capabilities
• Architectural design and data flow within New Relic
• Agents, collectors, and telemetry data management
• Overview of metrics, events, logs, traces, and error reporting
• Core monitoring modules: APM, browser, infrastructure, and database
• Concepts of entities, services, applications, and workloads
• Basics of distributed tracing and service dependencies
• Principles of data retention, querying, and visualization

Navigating the New Relic User Interface

• Exploring the New Relic platform and primary dashboards
• Managing applications, services, hosts, and entities
• Reviewing performance summaries and application health status
• Utilizing charts, tables, filters, and time-range selections
• Searching through and analyzing telemetry data
• Personalizing dashboards and views
• Constructing effective operational and performance dashboards
• Transitioning from high-level symptoms to detailed diagnostics using New Relic

Setting Up and Configuring New Relic Agents

• Agent architecture and supported environments
• Installation of New Relic agents on application servers
• Configuring agents for specific application monitoring needs
• Strategies for instrumentation: automatic vs. manual
• Setup for browser and end-user monitoring
• Verification of agent installation and telemetry collection
• Managing configuration and environment-specific parameters
• Resolving agent installation and data collection challenges
• Best practices for secure and maintainable agent deployment

Measuring Application Performance from the End-User Perspective

• Concepts of Real User Monitoring (RUM)
• Assessing page load and application response times
• Tracking browser performance and user interactions
• Pinpointing slow pages, transactions, and user journeys
• Evaluating performance variations based on geography and device
• Linking end-user experience with backend application performance
• Identifying issues that directly impact customer satisfaction
• Prioritizing optimization efforts based on performance data

Reading and Understanding Instrumentation Data

• Interpreting transaction traces and application activities
• Analyzing response time, throughput, and error-rate metrics
• Understanding transaction breakdowns and performance segments
• Assessing external services and dependencies
• Examining application errors and associated traces
• Pinpointing bottlenecks through instrumentation data
• Tracing request paths across application components
• Correlating metrics, events, logs, and traces for root-cause analysis
• Practical exercises in interpreting application telemetry

Measuring Application Resources and Infrastructure

• Monitoring resource usage for applications and servers
• Understanding performance of CPU, memory, disk, and network
• Detecting resource saturation and capacity constraints
• Linking infrastructure metrics with application response times
• Tracking application processes and workloads
• Identifying transactions with high resource consumption
• Investigating performance drops caused by infrastructure limits
• Establishing performance baselines and detecting anomalies

Monitoring and Notifications

• Fundamentals of alerting in New Relic
• Setting alert conditions and thresholds
• Creating alerts for performance and availability
• Tracking error rates, response times, throughput, and resource use
• Designing practical alert policies
• Setting up notification channels and incident workflows
• Minimizing alert noise to avoid unnecessary interruptions
• Understanding incident management and issue correlation
• Testing and validating alert setups
• Best practices for proactive monitoring

Monitoring Database Operations

• The link between database performance and application efficiency
• Monitoring database calls and query activity
• Identifying slow database operations
• Analyzing database response times
• Detecting inefficient or resource-heavy queries
• Correlating database activities with application transactions
• Investigating application bottlenecks related to the database
• Using performance data to enhance query speeds
• Practical exercises for diagnosing database performance problems

Reporting and Visualizing Application Performance

• Creating impactful performance reports
• Building dashboards for dev, ops, and management teams
• Selecting appropriate metrics for different audiences
• Visualizing availability, response time, throughput, and errors
• Tracking performance trends over time
• Comparing performance across different environments
• Presenting technical metrics as business-relevant insights
• Establishing baselines and reporting against objectives

Analyzing and Optimizing Application Performance

• Developing a systematic approach to performance analysis
• Identifying bottlenecks and unusual behavior
• Analyzing transaction response times and throughput
• Comparing current performance with historical baselines
• Correlating multiple telemetry sources during investigations
• Prioritizing issues based on user and business impact
• Finding opportunities for application optimization
• Validating improvements using New Relic data
• Hands-on exercises in performance analysis

Troubleshooting API and Service Issues

• Monitoring APIs and external service dependencies
• Measuring API response time, throughput, and error rates
• Identifying slow or unreliable API endpoints
• Diagnosing timeout and connectivity problems
• Analyzing failed API transactions
• Using traces to find bottlenecks in distributed services
• Linking API issues with downstream dependencies
• Pinpointing the root cause of API performance issues
• Developing and validating remediation strategies

Distributed Tracing and End-to-End Troubleshooting

• Understanding distributed applications and service dependencies
• Intro to distributed tracing concepts
• Following requests across multiple application services
• Identifying latency introduced by specific services
• Analyzing communication between services
• Detecting failures in distributed components
• Correlating traces with logs, errors, and infrastructure metrics
• Conducting end-to-end root-cause analysis
• Practical troubleshooting scenarios in a live-lab environment

Querying and Analyzing New Relic Data

• Intro to querying telemetry data in New Relic
• Understanding New Relic Query Language (NRQL)
• Writing queries to investigate performance
• Filtering and aggregating metrics and events
• Analyzing response times, errors, throughput, and transactions
• Creating custom visualizations from query results
• Using queries for troubleshooting and reporting
• Building reusable queries and dashboards
• Practical NRQL exercises

Integrating New Relic with Third-Party Tools and Services

• Overview of New Relic integrations
• Integrating with infrastructure and cloud platforms
• Connecting with collaboration and incident-management tools
• Understanding integration workflows and data exchange
• Configuring notifications and external service integrations
• Supporting DevOps and incident-response processes through integrations
• Best practices for reliable monitoring integrations

Practical Troubleshooting Workshop

• Investigating a simulated performance incident
• Identifying symptoms from end-user data
• Analyzing transactions and errors
• Investigating infrastructure and database performance
• Tracing API and external service dependencies
• Correlating metrics, events, logs, and traces
• Identifying the most likely root cause
• Developing and validating a remediation approach
• Configuring alerts to prevent recurrence
• Documenting findings and communicating business impact

Monitoring Best Practices and Operational Recommendations

• Designing an effective New Relic monitoring strategy
• Selecting meaningful performance and availability metrics
• Establishing baselines and service-level objectives
• Avoiding excessive monitoring noise
• Developing effective alerting and escalation practices
• Maintaining consistent monitoring across dev, test, and production
• Using observability data to support continuous improvement
• Translating technical data into actionable business insights

Summary and Conclusion

• Review of New Relic architecture and core capabilities
• Review of application, infrastructure, database, API, and end-user monitoring
• Recap of troubleshooting and root-cause analysis techniques
• Review of alerting, dashboards, reporting, and integrations
• Final hands-on performance investigation
• Discussion of real-world implementation scenarios
• Questions and answers
• Recommended next steps for production environments