Application Performance Management (APM) with New Relic Training Course

Foundations of Application Performance Monitoring

• Grasping Application Performance Management (APM) and its significance in modern application operations.
• Exploring the link between application performance, availability, reliability, and customer experience.
• Key performance indicators and service-level objectives.
• Recognizing common causes of performance degradation in applications.
• The monitoring lifecycle: observation, analysis, diagnosis, remediation, and optimization.
• The role of New Relic in comprehensive full-stack observability.

New Relic Capabilities and Structure

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

Exploring the New Relic Interface

• Navigating 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 selectors.
• Searching and analyzing telemetry data effectively.
• Customizing dashboards and views to suit specific needs.
• Constructing operational and performance dashboards that provide value.
• Using New Relic to drill down from high-level symptoms to detailed diagnostics.

Deployment and Configuration of New Relic Agents

• Understanding agent architecture and supported environments for New Relic.
• Installing New Relic agents on application servers.
• Tailoring agent settings for specific application monitoring requirements.
• Strategies for instrumentation: automatic vs. manual approaches.
• Setting up browser and end-user monitoring.
• Verifying agent installation and confirming telemetry collection.
• Managing configuration and environment-specific parameters.
• Resolving issues related to agent installation and data gathering.
• Best practices for secure and sustainable agent deployment.

Assessing Performance from the End-User Viewpoint

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

Interpreting Instrumentation Data

• Understanding transaction traces and application transactions.
• Reading response time, throughput, and error-rate data.
• Analyzing transaction breakdowns and performance segments.
• Examining external services and their dependencies.
• Reviewing application errors and error traces.
• Spotting bottlenecks through instrumentation data.
• Using traces to track requests across various application components.
• Correlating metrics, events, logs, and traces for root-cause analysis.
• Hands-on exercises in interpreting application telemetry.

Tracking Application Resources and Infrastructure

• Monitoring resource usage across applications and servers.
• Understanding CPU, memory, disk, and network performance metrics.
• Identifying resource saturation and capacity-related problems.
• Connecting infrastructure metrics to application response times.
• Monitoring application processes and workloads.
• Spotting resource-heavy transactions.
• Investigating performance drops caused by infrastructure limits.
• Setting performance baselines and spotting anomalies.

Monitoring and Alert Systems

• Core concepts of New Relic alerting.
• Setting alert conditions and thresholds.
• Creating alerts for application performance and availability.
• Monitoring error rates, response times, throughput, and resource usage.
• Designing practical alert policies.
• Setting up notification channels and incident workflows.
• Minimizing alert fatigue and avoiding unnecessary notifications.
• Understanding incidents and issue correlation.
• Testing and validating alert setups.
• Best practices for proactive application monitoring.

Database Operations Monitoring

• The link between database performance and application performance.
• Tracking database calls and query activity.
• Identifying slow database operations.
• Analyzing database response times.
• Detecting inefficient or resource-heavy queries.
• Connecting database operations to application transactions.
• Investigating bottlenecks related to the database.
• Using performance data to enhance query speeds.
• Practical exercises in diagnosing database performance issues.

Reporting and Visualizing Performance

• Generating meaningful performance reports.
• Building dashboards for development, operations, and management teams.
• Choosing the right 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.

Performance Analysis and Optimization

• Establishing a structured process for performance analysis.
• Identifying bottlenecks and abnormal behavior.
• Analyzing transaction response times and throughput.
• Comparing current performance against historical baselines.
• Correlating multiple data sources during investigations.
• Prioritizing issues based on user and business impact.
• Finding opportunities for optimization.
• Verifying improvements using New Relic data.
• Hands-on exercises in performance analysis.

Resolving API and Service Issues

• Monitoring APIs and external service dependencies.
• Measuring API response times, 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.
• Connecting API issues with downstream dependencies.
• Identifying the root cause of API performance drops.
• Developing and validating fixes.

Distributed Tracing and End-to-End Resolution

• Understanding distributed applications and service dependencies.
• Introduction to distributed tracing concepts.
• Tracking requests across multiple services.
• Identifying latency added 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

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

Integration with Third-Party Tools

• Overview of New Relic integrations.
• Connecting New Relic with infrastructure and cloud platforms.
• Linking 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.
• Best practices for maintaining reliable 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 likely root cause.
• Developing and validating a remediation plan.
• Setting alerts to prevent recurrence.
• Documenting findings and communicating business impact.

Monitoring Best Practices

• Designing an effective monitoring strategy for New Relic.
• 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 drive continuous improvement.
• Translating technical data into actionable business insights.

Wrap-Up and Conclusion

• Review of New Relic architecture and core features.
• Review of monitoring across application, infrastructure, database, API, and end-user levels.
• Recap of troubleshooting and root-cause analysis methods.
• 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.