Application Performance Management (APM) with New Relic Training Course

Introduction to Application Performance Monitoring

• Comprehending Application Performance Management (APM) and its role in modern application operations.
• The relationship between application performance, availability, reliability, and customer experience.
• Key application performance indicators and service-level objectives.
• Identifying common sources of application performance degradation.
• Overview of the application monitoring lifecycle: observe, analyze, diagnose, remediate, and optimize.
• Understanding the role of New Relic in full-stack observability.

New Relic Features and Architecture

• Overview of the New Relic platform and its core capabilities.
• Understanding New Relic architecture and data flow.
• New Relic agents, collectors, and telemetry data.
• Overview of metrics, events, logs, traces, and errors.
• Application Performance Monitoring (APM), browser monitoring, infrastructure monitoring, and database monitoring.
• Understanding entities, services, applications, and workloads.
• Introduction to distributed tracing and service dependencies.
• Understanding data retention, querying, and visualization concepts.

Navigating the New Relic User Interface

• Navigating the New Relic platform and main dashboards.
• Working with applications, services, hosts, and entities.
• Exploring performance summaries and application health.
• Using charts, tables, filters, and time ranges.
• Searching and analyzing telemetry data.
• Customizing dashboards and views.
• Creating useful operational and performance dashboards.
• Using New Relic to move from high-level symptoms to detailed diagnostics.

Setting Up and Configuring New Relic Agents

• Understanding New Relic agent architecture and supported environments.
• Installing New Relic agents on application servers.
• Configuring agents for application-specific monitoring.
• Instrumentation strategies and automatic versus manual instrumentation.
• Configuring browser and end-user monitoring.
• Validating agent installation and telemetry collection.
• Managing configuration and environment-specific settings.
• Troubleshooting agent installation and data collection issues.
• 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 times.
• Monitoring browser performance and user interactions.
• Identifying slow pages, transactions, and user journeys.
• Analyzing geographic and device-based performance differences.
• Correlating end-user experience with backend application performance.
• Identifying performance issues that directly affect customer experience.
• Using performance data to prioritize optimization activities.

Reading and Understanding Instrumentation Data

• Understanding transaction traces and application transactions.
• Interpreting response time, throughput, and error-rate data.
• Understanding transaction breakdowns and performance segments.
• Analyzing external services and dependencies.
• Examining application errors and error traces.
• Identifying bottlenecks from instrumentation data.
• Using traces to follow requests 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 application and server resource utilization.
• Understanding CPU, memory, disk, and network performance.
• Identifying resource saturation and capacity-related issues.
• Correlating infrastructure metrics with application response times.
• Monitoring application processes and workloads.
• Identifying resource-intensive transactions.
• Investigating performance degradation caused by infrastructure constraints.
• Establishing performance baselines and identifying abnormal behavior.

Monitoring and Notifications

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

Monitoring Database Operations

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

Reporting and Visualizing Application Performance

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

Analyzing and Optimizing Application Performance

• Establishing a systematic application performance analysis process.
• Identifying performance bottlenecks and abnormal behavior.
• Analyzing transaction response times and throughput.
• Comparing current performance with historical baselines.
• Correlating multiple telemetry sources during investigations.
• Prioritizing performance problems according to user and business impact.
• Identifying opportunities for application optimization.
• Validating performance 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 error rates.
• Identifying slow and unreliable API endpoints.
• Diagnosing timeout and connectivity issues.
• Analyzing failed API transactions.
• Using traces to identify bottlenecks across distributed services.
• Correlating API problems with downstream dependencies.
• Identifying the root cause of API performance degradation.
• Developing and validating remediation strategies.

Distributed Tracing and End-to-End Troubleshooting

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

Querying and Analyzing New Relic Data

• Introduction to querying telemetry data in New Relic.
• Understanding the New Relic Query Language (NRQL).
• Writing queries to investigate application performance.
• Filtering and aggregating metrics and events.
• Analyzing response times, errors, throughput, and transaction data.
• 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 New Relic with infrastructure and cloud platforms.
• Connecting monitoring data with collaboration and incident-management tools.
• Understanding integration workflows and data exchange.
• Configuring notifications and external service integrations.
• Using integrations to support DevOps and incident-response processes.
• Best practices for maintaining reliable monitoring integrations.

Practical Troubleshooting Workshop

• Investigating a simulated application performance incident.
• Identifying symptoms from end-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 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 development, testing, and production.
• Using observability data to support continuous improvement.
• Translating technical performance 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 applying New Relic in production environments.