Skip to main content
Version: NG-3.1

Application Performance Monitoring

Application Performance Monitoring (APM) in vuSmartMaps provides a unified observability experience for monitoring, analyzing, and troubleshooting modern distributed applications. In today’s microservices-driven environments, applications consist of multiple services, dependencies, and external systems. Identifying performance issues or failures in such systems requires more than isolated metrics it requires end-to-end visibility across services, transactions, and infrastructure.

APM addresses this by combining:

  • Service-level visibility (Service Catalogue, Service Map)
  • Transaction and trace analysis (Transactions, Trace Listing, TraceMap)
  • Operational insights (Operations, Latency Analysis, Error Analysis, Exception Analysis)

This integrated approach enables users to:

  • Monitor application health in real time
  • Identify impacted services and dependencies
  • Analyze request flows across distributed systems
  • Detect and troubleshoot performance bottlenecks and failures

The APM module is designed as a workflow-driven system, where users can start from a high-level overview (Service Catalogue) and progressively drill down into detailed analysis (service → transaction → trace → span) to identify root causes efficiently.

Key Concepts in APM​

  • Application: An application represents a logical system composed of multiple services that together deliver a business function.
  • Service: A service is an independent component responsible for a specific function within an application (for example, API service, database service, messaging service).
  • Transaction: A transaction represents a request or operation processed by a service, such as an API call or user action.
  • Trace: A trace represents the end-to-end journey of a request across multiple services.
  • Span: A span represents a single operation within a trace, such as an API call, database query, or internal processing step.
  • Service Map: A Service Map visualizes service dependencies and interactions, helping identify communication paths and potential bottlenecks.
  • RED Metrics: APM uses RED metrics to evaluate service performance:
    • Rate → Request volume
    • Errors → Failed requests
    • Duration → Response time

APM Capabilities​

APM provides a comprehensive set of capabilities to monitor, analyze, and troubleshoot application performance across distributed environments. These capabilities are designed to support end-to-end workflows, from high-level visibility to deep root cause analysis.

Service-Level Visibility​

APM provides a centralized view of all services within an application, enabling you to monitor performance and health at a glance.

  • Track key performance indicators such as request rate, error rate, and latency (RED metrics)
  • Identify critical and underperforming services
  • Analyze service behavior across applications and environments

This is primarily enabled through dashboards such as Service Catalogue and Service Map.

Dependency and Interaction Analysis​

APM visualizes how services interact with each other and external dependencies.

  • Understand upstream and downstream service relationships
  • Identify bottlenecks in service communication
  • Analyze the impact of dependent services such as databases and external APIs

This capability helps in quickly isolating issues across complex microservice architectures.

Distributed Tracing and Deep Diagnostics​

APM enables end-to-end tracing of requests across services.

  • Track the complete flow of a transaction across services
  • Analyze execution at the span level for granular visibility
  • Identify slow or failing operations within a request

This supports detailed investigation using Trace Listing, Trace Map, and span-level views.

Performance and Error Analysis​

APM provides focused analysis of latency, errors, and performance trends.

  • Identify high-latency transactions and performance degradation
  • Analyze error distribution by type, status code, and exception
  • Correlate performance issues with traffic patterns and system behavior

These insights help in prioritizing and resolving issues effectively.

Instrumentation and Data Collection​

APM leverages OpenTelemetry-based instrumentation to collect trace data from applications.

  • Supports automatic and manual instrumentation approaches
  • Collects telemetry data across services, infrastructure, and dependencies
  • Enables standardized and scalable observability across environments

This ensures consistent and reliable data collection for analysis.

Service Catalogue and Contextual Analysis​

APM provides structured views of services and their associated metrics.

  • Manage and analyze services within application contexts
  • Compare service performance using key metrics
  • Identify dependencies and supporting services

This enables a structured and scalable approach to monitoring large systems.

End-to-End Troubleshooting Workflow​

APM is designed as a workflow-driven system:

  • Start from service-level overview
  • Drill down into transactions and operations
  • Analyze individual traces and spans
  • Identify root causes and performance bottlenecks

This guided approach reduces the time required for issue detection and resolution.

Key Benefits​

  • Real-Time Observability: Gain continuous visibility into application performance and behavior
  • Faster Issue Resolution: Identify and troubleshoot issues quickly using drill-down workflows
  • Improved Reliability: Detect and resolve performance bottlenecks and failures proactively
  • Scalable Monitoring: Monitor complex, distributed systems with multiple services and dependencies
  • Actionable Insights: Make informed decisions using correlated metrics, traces, and contextual data

End-to-End Workflow​

The following workflow describes how APM and APM Studio work together to collect, process, analyze, and refine observability data.

Step 1: Enable Traces O11ySource and Configure Data Sources​

  • Enable the Traces O11ySource in vuSmartMaps and configure the required data sources for trace collection.
  • This step establishes the telemetry ingestion pipeline and defines how trace data will be received and processed by the platform.

For more information, refer to:

Step 2: Instrument the Application​

Applications are instrumented using OpenTelemetry or supported instrumentation packages to generate trace data.

Instrumentation can be configured based on the deployment environment, such as:

  • Host/VM
  • Docker
  • Kubernetes

For more information, refer to:

Step 3: Data Ingestion into APM​

Once instrumentation is configured, telemetry data is ingested into APM, where services, requests, traces, and dependencies become visible across dashboards and analysis views.

For more information, refer to:

Step 4: Analyze in APM​

Users analyze:

  • service performance
  • request behavior
  • latency trends
  • error patterns
  • dependency interactions

During this stage, users may identify:

  • unclear service naming
  • noisy request patterns
  • incorrect failure detection
  • excessive or missing attributes

Step 5: Refine using APM Studio​

Users navigate to APM Studio to improve trace interpretation and observability quality.

This includes:

  • Naming → Standardize service and request names
  • Classification → Highlight important services and requests
  • Failures → Define custom failure detection logic
  • Data Control → Filter, mask, or enrich attributes

Step 6: View Refined Data in APM​

After applying APM Studio configurations, the updated logic is reflected across APM dashboards and trace analysis views.

This improves:

  • service readability
  • trace clarity
  • failure visibility
  • troubleshooting efficiency

The refined observability data enables faster analysis and more effective root cause identification.

note

For advanced trace customization and rule-based configuration, refer to the APM Studio documentation.

APM Studio Integration​

APM Studio acts as a configuration layer for APM, allowing you to control how trace data is interpreted before it appears in APM dashboards and analysis views. While APM provides visibility into application performance through traces, service maps, and metrics, APM Studio enables you to refine and enhance this data to better reflect your business context.

Using APM Studio, you can:

  • Standardize service, request, and operation naming
  • Prioritize critical services and requests
  • Define accurate failure detection logic
  • Control, filter, and enrich telemetry data

Any changes configured in APM Studio are automatically reflected across APM views such as:

  • Service Map
  • Service List
  • Trace Analysis
  • Dashboards and Metrics

This ensures that the data you analyze in APM is clean, meaningful, and aligned with your application architecture and business requirements.

note

For detailed configuration steps and rule definitions, refer to the APM Studio documentation.

When to Use APM Studio​

APM Studio should be used whenever the default telemetry data does not accurately represent your application behavior or business context. Common scenarios include:

  • Service names appear inconsistent or unclear
  • Request names are too technical or difficult to interpret
  • Important services are not clearly distinguishable
  • Failure detection does not match actual application behavior
  • Trace data contains unnecessary or sensitive attributes
  • Observability views contain too much noise

In such cases, APM Studio allows you to customize how data is processed so that APM reflects a more accurate and meaningful view of your application.

note

For detailed configuration steps and rule definitions, refer to the APM Studio documentation.