Application Performance Management (APM) with New Relic Training Course

Introduction to Application Performance Monitoring

• Understanding the role of Application Performance Management (APM) in modern operations.
• The connection between performance, availability, reliability, and user experience.
• Essential performance indicators and service-level objectives.
• Recognizing common causes of performance decline.
• The monitoring lifecycle: observation, analysis, diagnosis, remediation, and optimization.
• The role of New Relic in comprehensive full-stack observability.

New Relic Features and Architecture

• Overview of the New Relic platform and its primary functions.
• Understanding the architecture and data flow mechanisms.
• Role of agents, collectors, and telemetry data.
• Overview of metrics, events, logs, traces, and errors.
• Coverage of APM, browser, infrastructure, and database monitoring.
• Understanding entities, services, applications, and workloads.
• Introduction to distributed tracing and service dependencies.
• Concepts of data retention, querying, and visualization.

Navigating the New Relic User Interface

• Browsing the platform and primary dashboards.
• Managing applications, services, hosts, and entities.
• Reviewing performance summaries and overall health.
• Utilizing charts, tables, filters, and time-range selections.
• Searching and analyzing telemetry data effectively.
• Personalizing dashboards and views for specific needs.
• Building operational and performance-focused dashboards.
• Using New Relic to transition from symptom identification to detailed diagnosis.

Setting Up and Configuring New Relic Agents

• Understanding agent architecture and supported environments.
• Installing agents on application servers.
• Configuring agents for specific application monitoring requirements.
• Instrumentation strategies: automatic vs. manual approaches.
• Configuring browser and end-user monitoring.
• Verifying installation and telemetry collection success.
• Managing configuration and environment-specific settings.
• Troubleshooting installation and data collection challenges.
• Best practices for secure and maintainable agent deployment.

Measuring Application Performance from the End-User Perspective

• Understanding Real User Monitoring (RUM).
• Measuring page-load and application response metrics.
• Monitoring browser performance and user interactions.
• Identifying slow pages, transactions, and user journeys.
• Analyzing performance variations by geography and device type.
• Linking end-user experience to backend application performance.
• Identifying issues that directly impact customer satisfaction.
• Using performance data to prioritize optimization efforts.

Reading and Understanding Instrumentation Data

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

Measuring Application Resources and Infrastructure

• Monitoring application and server resource usage.
• Understanding CPU, memory, disk, and network metrics.
• Identifying resource saturation and capacity issues.
• Correlating infrastructure metrics with application response times.
• Monitoring application processes and workloads.
• Identifying resource-intensive transactions.
• Investigating performance drops due to infrastructure constraints.
• Establishing baselines and detecting abnormal behavior.

Monitoring and Notifications

• Understanding New Relic alerting concepts.
• Defining alert conditions and thresholds.
• Creating alerts for performance and availability metrics.
• Monitoring error rates, response times, throughput, and resource use.
• Designing actionable alert policies.
• Configuring notification channels and incident workflows.
• Reducing alert noise and preventing unnecessary notifications.
• Understanding incidents and issue correlation.
• Testing and validating alert setups.
• Best practices for proactive monitoring.

Monitoring Database Operations

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

Reporting and Visualizing Application Performance

• Creating meaningful 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 insights.
• Establishing baselines and reporting against objectives.

Analyzing and Optimizing Application Performance

• Establishing a systematic analysis process.
• Identifying bottlenecks and abnormal 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.
• Identifying opportunities for optimization.
• Validating improvements using New Relic data.
• Hands-on performance analysis exercises.

Troubleshooting API and Service Issues

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

Distributed Tracing and End-to-End Troubleshooting

• Understanding distributed applications and service links.
• Introduction to distributed tracing concepts.
• Following requests across multiple services.
• Identifying latency from individual services.
• Analyzing service-to-service communication.
• Detecting failures across distributed components.
• Correlating traces with logs, errors, and infrastructure metrics.
• Performing end-to-end root-cause analysis.
• Practical troubleshooting scenarios in a live lab.

Querying and Analyzing New Relic Data

• Introduction to querying telemetry data.
• Understanding the 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 to support 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 monitoring data with collaboration and incident tools.
• Understanding integration workflows and data exchange.
• Configuring notifications and external service links.
• Using integrations for DevOps and incident response.
• Best practices for maintaining reliable integrations.

Practical Troubleshooting Workshop

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

Monitoring Best Practices and Operational Recommendations

• Designing an effective 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 all environments.
• Using observability data to support continuous improvement.
• Translating technical data into actionable business insights.

Summary and Conclusion

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