Thank you for sending your enquiry! One of our team members will contact you shortly.
Thank you for sending your booking! One of our team members will contact you shortly.
Course Outline
Introduction to Application Performance Monitoring
- Understanding 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
Requirements
- A general understanding of application infrastructure concepts
- Experience with the Linux command line
Audience
- Developers
- DevOps engineers
- Test engineers
- System administrators
- Solution Architects
28 Hours
