Products > vuApp360

vuApp360 – Application Observability


In today’s fast-paced digital environment, the ability to gain real-time performance insights of the application’s behavior and its associated infrastructure components is very important. Welcome to vuApp360 – VuNet’s Application Observability product designed to elevate your Application Performance Monitoring (APM) experience. The APM sub-module, within the broader vuApp360 suite, provides a comprehensive set of tools that extend beyond traditional log and metric observability. Notably, it introduces Traces – a cutting-edge addition that completes the observability matrix.

VuNet’s vuApp360 accelerates issue detection and resolution by seamlessly integrating traces with logs, metrics, and additional telemetry. This comprehensive approach enhances application performance, ensures security measures, optimizes resource utilization, and fosters improved collaboration, resulting in an elevated user experience. By leveraging vuApp360, you’ll not only observe and analyze but also optimize your applications’ performance to unlock their full potential. vuApp360 empowers you to swiftly detect and troubleshoot performance issues, ensuring a seamless and delightful user experience.

Getting Started with vuApp360


  • Before initiating the vuApp360 integration for your application with vuApp360, it’s crucial to ensure that your setup meets the following prerequisites, listed in the Language Compatibility Matrix below:


Supported Version(s)


  • Java 8 or above


  • Node.JS v14
  • Node.JS v16
  • Node.JS v18


  • go1.18
  • go1.19

.NET Core

  • .NET Core 5.0
  • .NET Core 6.0
  • .NET Core 7.0

.NET Framework

  • .NET Framework 4.6.2
  • .NET Framework 4.7
  • .NET Framework 4.7.1
  • .NET Framework 4.7.2
  • .NET Framework 4.8

  • Port Opening: Unidirectional access from the client machine/VM, Docker image, or Kubernetes pod to the vuSmartMaps platform, where the OTEL collector runs on ports 4317 and 4318.
  • Ensure vuSmartMaps is installed and running to enable comprehensive real-time performance monitoring and analysis for your application.

Understanding vuApp360 Terminologies

An application refers to a program or software system designed to perform specific tasks or functions to meet the needs of users or businesses. Applications can range from simple single-purpose programs to complex, multi-tiered systems deployed across various platforms and devices. For example, banking applications such as mobile banking, internet banking, instant payment apps.

A service refers to a self-contained unit of functionality that performs a specific task or provides a specific capability. Services are typically designed to be modular, reusable, and independent, allowing them to be easily integrated into larger software systems. Services can communicate with each other over a network using standardized protocols, such as HTTP or RPC (Remote Procedure Call).

Service Examples:

  1. A group of URL endpoints may be grouped under an API service.
  2. A group of DB queries that are grouped within one database service.
  3. A group of periodic jobs configured in the crond service.

A service map is a visual representation illustrating the relationships and dependencies among various services within an application system, demonstrating how these services interact and the flow of data between them. This graphical representation is crucial for understanding the application’s architecture, identifying potential vulnerabilities, and optimizing overall performance.

vuApp360 is capable of automatically identifying millions of causal dependencies among websites, applications, services, processes, hosts, networks, and infrastructure within near real time. The comprehensive application topology is visually presented in an interactive and dynamic format. This includes all infrastructure components and dependencies across the entire technology stack, providing a complete overview.

In the context of the service map, telemetry data refers to the various metrics, logs, and traces collected from the underlying services and components within the monitored system. This includes information related to the performance, health, and behavior of services. Telemetry data provides valuable insights into how different services interact, their response times, error rates, and other relevant metrics. By accessing this telemetry data directly from the service map interface, users can gain a comprehensive understanding of the system’s status, identify potential issues, and make informed decisions for optimization and troubleshooting.

API Transactions play a pivotal role in providing observability engineers with a robust interface to seamlessly integrate performance monitoring into their code. By leveraging this functionality, developers can effectively track and analyze transactions or requests as they traverse through a software system. The benefits for users are significant, offering the ability to define and record custom metrics and traces tailored to specific transactions. This level of customization empowers developers to delve deeply into the system’s performance, enabling swift issue identification and targeted optimizations. For example, consider the tangible advantages of utilizing a “User Registration API Transaction” – developers can meticulously monitor user registration processes, ensuring efficiency and reliability. Similarly, a “Payment Processing API Transaction” facilitates precise tracking and optimization of payment processing tasks, ultimately enhancing the overall user experience and system performance.

Distributed tracing is a powerful method employed to monitor and debug intricate, distributed software systems. By instrumenting applications, distributed tracing generates traces that offer valuable insights into the flow of requests or transactions throughout the system. This technique plays a crucial role in enhancing visibility, allowing developers to pinpoint performance issues, troubleshoot errors, and optimize the overall behavior of the system.

Additionally, distributed tracing serves as a comprehensive method for tracking application requests, providing a detailed perspective on their journey from frontend devices to backend services and databases. Developers leverage distributed tracing not only for system optimization but also as a troubleshooting tool, particularly for requests exhibiting high latency or errors. This multifaceted approach ensures a thorough understanding of application behavior, enabling developers to fine-tune performance and deliver an exceptional user experience.


Imagine you’re ordering food from an online delivery platform like Uber Eats or DoorDash. When you place your order, several services are involved in processing it:

  1. Frontend Service: Takes your order details and sends them to the backend.
  2. Backend Service: Processes your order, confirms with the restaurant, and handles payment.
  3. Restaurant Service: Prepares the food and marks the order as ready.
  4. Delivery Service: Manages driver assignment, tracks delivery, and updates you.

With distributed tracing:

  1. Generates a unique identifier for your order.
  2. Logs information with the identifier as it flows through each service.
  3. Enables tracing using the identifier to identify delays or errors.
  4. Analyzes the distributed trace to pinpoint where delays occurred.

This example showcases how distributed tracing visualizes and analyzes request flow across services, aiding effective diagnosis and troubleshooting in distributed systems.

A trace is a detailed record of the execution path of a transaction or request as it flows through a software system. Traces typically include information such as the start and end times of the transaction, the services or components involved, any errors encountered, and the latency of each step in the process. Traces are used in distributed tracing systems to provide visibility into the performance and behavior of complex, distributed systems.

A trace is used to track the time spent by an application processing a request and the status of this request. Each trace consists of one or more spans. During the lifetime of the request, you can see distributed calls across services, and automatically instrumented libraries, in the flame graph view. Each trace gathers valuable information that establishes connections with various components of the platform. This includes linking logs to traces, incorporating tags into spans, and gathering runtime metrics.

Traces Observability Source (O11ySource) is one of the founding pillars of our comprehensive application observability solution, providing in-depth visibility into application performance through standard monitoring dashboards and out-of-the-box proactive alerts. Designed for effortless application onboarding, Traces O11ySource utilizes tracing libraries tailored for popular programming languages. It efficiently collects distributed traces, forwarding them to the vuSmartMaps platform for deep application observability. This foundational component ensures vigilant monitoring of critical metrics like request rate, error rate, and duration, facilitating swift identification of performance bottlenecks.

Traces O11ySource simplifies the intricate process of instrumenting the client-side application and seamlessly integrating data into vuApp360. We’ve packaged the complex steps into an easy-to-follow process for the end-user. By enabling Traces O11ySource, configuring the source, and instrumenting the application with our instrumentation package, users can effortlessly unlock the power of application observability with vuApp360.

Traces O11ySource serves as the infrastructure for collecting, processing, storing, and analyzing traces from applications. This foundational element manages client instrumentation configurations and collector configurations, streamlining the process of observability. With Traces O11ySource, VuNet provides a robust framework that seamlessly orchestrates trace data, providing the necessary tools for effective performance analysis and optimization. It’s the key to unlocking a comprehensive understanding of application behavior and ensuring a seamless user experience.

OpenTelemetry, or OTel, is an open-source framework developed by the Cloud Native Computing Foundation (CNCF) to streamline the instrumentation, collection, and analysis of telemetry data from software applications. Its significance lies in its standardized APIs, libraries, and tools, which simplify the process of capturing and propagating context, generating traces, and collecting telemetry data across different languages and frameworks.

OTel’s vendor neutrality and interoperability enable seamless integration with various observability tools and platforms, facilitating efficient utilization of existing infrastructure. Moreover, OTel supports comprehensive and transparent data collection, offering real-time monitoring capabilities crucial for prompt issue identification and resolution. Additionally, its support for distributed tracing provides end-to-end visibility into complex system architectures, aiding in troubleshooting and enhancing system reliability.

The OTel Collector, serving as the telemetry receiver, plays a crucial role in capturing telemetry signals emitted by instrumented applications. This component seamlessly collects data, enabling comprehensive insights into the performance and behavior of your applications.

By default, the OTel Collector incorporates tail sampling configurations designed to enhance your observability experience. These configurations encompass the following rules:

  1. Allow All Error Traces: Ensuring that every error trace is captured for thorough analysis.
  2. Allow All Slow Traces (Duration > 5 seconds): Capturing traces with a duration exceeding 5 seconds, aiding in the identification of potential performance bottlenecks.
  3. Block Static Resources (CSS, JS, Images, etc.): Filtering out static resources to focus on dynamic aspects of application behavior.
  4. Block Specific Requests (/ping, /health): Filtering requests to endpoints such as /ping and /health, optimizing data relevance.
  5. Allow 30% of Normal Requests: Sampling a portion (30%) of regular requests for a representative view of overall system performance.

This default configuration ensures that the OTel Collector efficiently captures relevant telemetry data, providing you with actionable insights for effective performance monitoring and optimization.

Instrumentation is the crucial process of collecting telemetry data, specifically traces, from an application, adding a small software code that helps collect essential telemetry data for performance insights. O11ySources facilitates this by providing the required libraries and instructions for integration.

Instrumentation configurations vary based on the programming language used. However, with Traces O11ySource, users can efficiently configure instrumentation across all supported programming languages using a unified solution. This streamlined approach ensures a cohesive and straightforward process for collecting telemetry data, enhancing observability across diverse applications.

Instrumentation options include:

  1. Auto Instrumentation: The recommended, hassle-free method. Choose from our auto-instrumentation libraries, add the tracing library, and restart your app. The auto instrumentation requires no extensive code changes.
  2. Manual Instrumentation: For advanced users or unsupported languages. Developers add tracing APIs and code for trace generation.

💡Note: Traces O11ySource presently supports Auto Instrumentation only.

In the context of distributed tracing, a span represents a single operation or unit of work within a transaction or request. Spans capture information such as the start and end times of the operation, any associated metadata or tags, and any errors or exceptions that occur. Parent spans represent the overall transaction or request, while child spans represent sub-operations or tasks within the transaction. Spans help understand the flow of execution within a distributed system, identify performance bottlenecks, and diagnose issues.

  1. Parent Span: This span represents the overall transaction or request, encapsulating the entire journey from initiation to completion. For example, in an e-commerce application, the parent span would cover the entire checkout process, from adding items to the cart to order confirmation.
  2. Child Span: Child spans are subsets of the parent span, focusing on specific operations or tasks within the transaction. Each child span provides detailed insights into the performance of individual components. In the e-commerce example, child spans could include operations like user authentication, inventory retrieval, payment processing, and shipping confirmation.

Spans play a crucial role in distributed tracing, offering several advantages in understanding and optimizing the behavior of a system. Their high granularity allows for tracking individual operations, aiding in the identification of bottlenecks and performance optimization. The correlation of spans across services and machines provides a comprehensive view of the system’s flow of work or requests. Additionally, spans offer contextual information through metadata like tags and logs, facilitating debugging and diagnostics. Developers and operators leverage spans to trace code execution, identify issues, and pinpoint the root cause of problems within the system.


Consider the above example where the request originates from a frontend web client, initiating the first span known as the parent span, illustrating the overall time taken for the request. The parent span, in turn, triggers four services, each represented as a child span. These services include:

  1. auth: Responsible for authenticating the user.
  2. route: In charge of determining the nearest route.
  3. driver: Tasked with allocating the nearest driver.
  4. customer: Manages the addition of customer details.

Each of these child spans may, in turn, have additional child spans, contributing to a hierarchical representation of the operations within the distributed system.

TraceId is the unique identifier for the trace. All the spans associated with these requests will have the same TraceId. Each span possesses attributes like SpanId (a unique identifier for the span), and ParentSpanId, indicating the hierarchical relationship between operations where one operation calls the next.

The Root Span stands as the initial span in the trace, representing the starting point of the request. Notably, the ParentSpanId for the Root Span is empty, distinguishing it as the first operation in the trace hierarchy. This structure allows for a comprehensive understanding of the execution path and relationships between operations within the application.

A span operation encompasses a distinct task or operation executed by a component of the application. This can involve various activities such as managing an HTTP request, executing a database query, or processing a message received from a message queue. Spans provide a granular view of these individual operations within the larger scope of the application’s workflow.

In distributed tracing, spans represent timed operations within a trace, each having a start and end time along with metadata like tags and logs. They denote individual operations in a trace, allowing correlation across services and machines. On the other hand, a trace encapsulates the complete flow of work or requests through a system, consisting of multiple spans representing individual operations. Traces capture user service request data, including custom characteristics, event timelines, and spans with comprehensive metadata. In essence, a span is a unit of work within a trace, and collectively, traces provide a holistic view of the system’s behavior, aiding in issue diagnosis and performance optimization. For instance, a trace for a web application might encompass spans for the initial HTTP request, database query, and cache lookup, offering insights into system behavior.

RED metrics are a set of key performance indicators used in application performance monitoring. RED stands for:

  1. Request Rate: The number of requests handled by the system per unit of time. This metric measures the request rate or throughput of a service over a specific time period. It offers insights into the volume of requests handled by the service, aiding in workload assessment and capacity planning. Monitoring the request rate is crucial for making informed decisions about scaling and optimizing service performance.
  2. Error Rate: The rate of errors or failures encountered by the system while processing requests. Error metrics track the occurrence of errors or failed requests within a service, providing visibility into the system’s reliability and stability. Monitoring error rates enables teams to swiftly identify and troubleshoot issues, contributing to improved service reliability and an enhanced user experience.
  3. Duration: The time taken by the system to process individual requests, typically measured as latency or response time. Duration metrics gauge the time taken to process requests within a service, encompassing the time spent in various components such as processing, network latency, and database queries. Monitoring request duration is instrumental in identifying performance bottlenecks and optimizing service response times, ultimately enhancing the overall user experience.

RED metrics serve as indispensable indicators for monitoring and diagnosing service performance in a distributed system. They empower teams to ensure the reliability, scalability, and responsiveness of their applications.

A flame graph visualizes a distributed request trace and represents each service call that occurred during the request’s execution path with a timed, color-coded, horizontal bar. Flame graphs for distributed traces include error and latency data to help developers identify and fix bottlenecks in their applications. An example of the flame graph is shown below:

In microservice architectures, applications are composed of multiple, independently deployable services. Developers use distributed tracing to track a request as it flows through disparate services. A tracing tool collects latency and error data for the full request, as well as for each service call along the request’s pathway. A monitoring tool receives this data and displays it in the form of a flame graph.

Flame graphs allow developers to see the relationships between service calls and which parts of a request’s journey exhibited unusually high latency or errors. Sometimes, errors or high latency in one service can impact other, dependent services, so analyzing a flame graph can help you keep tabs on the performance of your application.

vuApp360 Architecture

At the heart of vuApp360 lies a robust and meticulously designed architecture that powers the comprehensive observability provided by Traces O11ySource. This architecture seamlessly integrates various components to ensure the efficient collection, processing, and visualization of trace data from applications.

To visualize this dynamic process, let’s take a look at the architecture diagram below.

The vuApp360 relies on the OpenTelemetry Software Development Kit (OTel SDK), which offers language-specific SDKs for widely-used programming languages. These SDKs are seamlessly integrated into the application, enabling the collection of traces. The traced data is then transmitted to the OTel Collector for further processing.

The OTel Collector acts as a central hub for trace data. Upon receiving traces from the OTel SDK, it meticulously processes the information and exports it to the ContextStream. As part of this process, the traces are divided into individual spans, and each span is subsequently pushed into the “traces-input” stream. This ensures that each message within this stream corresponds to a distinct span. It takes the spans available in the “traces-input” stream, performs the necessary data transformation, and forwards the modified data into the data store.

The processed and transformed data finds its home in VuNet’s HyperScale Data Store. This data store is designed to efficiently handle large-scale data, accommodating high-speed read and write operations effectively.

To make sense of the stored data, the architecture features an vuApp360 User Interface. The contextualized trace data is pulled from the HyperScale Data Store to create interactive dashboards, generate proactive alerts, and produce analytical reports related to Application Performance Monitoring. This comprehensive architecture ensures smooth and effective application observability.

Deployment and Configuration

Achieve streamlined trace collection by integrating our instrumentation library into the target application. Following this, a simple application restart activates the trace-capturing process. With these formal steps, the system is efficiently prepared to capture and forward traces to vuApp360, ensuring optimal observability. The process of configuring comprehensive application observability involves a two-step process:

  1. Configuring vuSmartMaps for Effective Tracing
    To enable effective tracing in vuApp360, start by configuring vuSmartMaps, the underlying platform. Activate the Traces O11ySource and set up data sources. This step is crucial, providing vuApp360 with real-time observability into application performance for proactive monitoring and in-depth analysis.

  2. Client-Side Instrumentation
    For client-side instrumentation, the next essential step involves updating the instrumentation package on the target application running on the client side. The process varies depending on the environment—whether it’s Host/VM, Docker, or Kubernetes. Follow the specific guidelines for the environment to seamlessly integrate vuApp360 and enhance the application’s performance with observability.

vuApp360 Features

With vuApp360, you have the power to keep a close watch on your application’s well-being, ensuring a seamless experience for the users. Navigate effortlessly through the application landscape, swiftly address issues, optimize efficiency, and make the most of your resources.

  1. Comprehensive Application Insights
    • Track vital metrics: request rate, error rate, and duration
    • Conduct site-level analysis for performance based on location
    • Associate services with applications for CXO-level business impact analysis
    • Dive deep into the application’s internal mechanics with code-level observability
  1. Service Map for Interaction Visualization
    • Visualize real-time interactions between different components
    • Utilize filters and drill-downs for deeper insights into performance bottlenecks
    • Provide CXOs with a quick bird’s eye view
  1. Distributed Tracing for Precise Insights
    • Trace transactions across complex microservices architecture
    • Automated and actionable insights for Root Cause Analysis (RCA)
    • Make data-driven decisions with detailed behavioral information from traces
  1. Instrumentation and Ingestion through OpenTelemetry
    • Comprehend internal application state through code insertion (instrumentation)
    • Automatically discover and map components, service interactions, and dependencies
    • Correlate telemetry data for a complete picture of transactions and workflows
  1. Service Catalog: Manage Services with Precision
    • Simplified service management at scale within microservice-based applications
    • Quickly identify dependencies and version changes for enhanced precision
    • Eliminate knowledge silos, fostering effective collaboration during incidents
    • Detect observability gaps for a comprehensive understanding of the application landscape to provide instant insights into performance and security
    • All services can be found in the Service Catalog and visually represented on the Service Map. Each service has its Service page where trace metrics like throughput, latency, and error rates can be viewed and inspected.
  1. Service Summary: Monitor with Consistency
    • Gain instant visibility into the health of every service and deployment using real-time RED metrics and correlated telemetry
    • Enhance application reliability by removing silos between teams and technologies
  1. Dynamic Trace Modification: Increase Trace Resolution
    • Modify and enrich distributed traces for deeper analysis without changing code
    • Increase the resolution of the traces at runtime by adding spans as needed, without affecting your original instrumentation
    • Add spans within the vuApp360 platform to troubleshoot slow requests and specific operations without leaving the environment.

Key Benefits:

  1. Real-time Observability
    • End-to-end infrastructure visibility
    • Single snapshot for metrics, errors, latencies, and incidents
  2. Faster Resolution
    • Scalable and flexible log management
    • Identify and address failed or delayed transactions swiftly
  3. Increased Stability
    • Connected views at scale
    • Superior performance and uptime
  4. Accelerated Releases
    • Rapid troubleshooting with effective RCA
    • Proficiency in managing application interactions and dependencies
    • Out-of-the-box visualizations, alerting, and reporting on complete application suite.

Experience vuApp360’s features, providing a holistic view and precise insights into your application’s performance, facilitating quick decision-making and proactive issue resolution.

vuApp360 Console

Welcome to the vuApp360 Console, your centralized hub for comprehensive Application Observability. vuApp360 console is designed to empower you with real-time insights, intelligent alerts, and detailed reports, all seamlessly integrated into vuApp360. Our pre-packaged vuApp360 dashboards, alerts, and insights provide an out-of-the-box solution for enhancing the target application’s performance, ensuring a seamless user experience with onboarding of the application with vuApp360.

  1. vuApp360 Dashboards
    Navigate through intuitive vuApp360 Dashboards providing a visual representation of critical metrics, including request rates, error rates, and latency. Gain a holistic view of your application’s health, identify bottlenecks, and track performance trends effortlessly.

  2. vuApp360 Alerts
    Stay ahead of potential issues with vuApp360 Alerts. Our intelligent alerting system keeps you informed about deviations from optimal performance, allowing for proactive issue resolution. Customize alerts to align with your specific thresholds and receive timely notifications to ensure uninterrupted application functionality.

  3. vuApp360 Reports
    Delve into the application’s performance with vuApp360 Reports. Generate detailed reports that offer historical perspectives, trend analyses, and actionable insights. Whether it’s for internal reviews or compliance purposes, vuApp360 Reports provide a comprehensive understanding of your application’s journey.

The vuApp360 Console serves as your command center, offering a unified platform to seamlessly navigate between dashboards, respond to alerts promptly, and generate insightful reports. Unlock the full potential of your applications with vuApp360 Console.

vuApp360 Real-world Applications

Proactive Latency Management

A SaaS company using vuApp360 observes an increase in latency during specific hours. The High Duration Alert configured in vuApp360 triggers notifications when the 90th percentile latency exceeds the predefined threshold. The team can proactively identify and address performance issues during peak times, ensuring a consistent and optimized user experience.

Effective Error Rate Mitigation

An e-commerce platform employing vuApp360 encounters a sudden spike in error rates. The High Error Rate Alert immediately notifies the operations team when the error rate surpasses the set threshold. With real-time insights into the affected services and transactions, the team can swiftly identify and resolve issues, minimizing the impact on user interactions.

Optimizing Request Rate for Scalability

A gaming application leveraging vuApp360’s Request Rate Alert notices a surge in user activity. The alert triggers when the request rate falls below the expected threshold, prompting the team to scale resources and optimize performance. This ensures the application can seamlessly handle increased user demand, preventing slowdowns or service disruptions.

Strategic Decision-Making with Application Quality Reports

A large enterprise using vuApp360 generates regular Application Quality Reports. These reports provide a holistic overview of application performance, infrastructure utilization, and customer impact. CXOs leverage these insights to make informed decisions, allocate resources efficiently, and enhance overall service quality, leading to improved customer satisfaction.

Banking Application Reliability

In the world of digital banking, reliability is paramount. vuApp360 ensures a seamless experience for users conducting financial transactions. It monitors critical aspects like account balance updates, fund transfers, transaction speeds, and the overall responsiveness of the banking application. This guarantees users a reliable and efficient banking experience, fostering trust and satisfaction.

Enhancing Food Delivery Experience

Imagine placing an order through a popular food delivery app. With vuApp360, it’s similar to having a vigilant chef in the kitchen, ensuring every step of your order is seamlessly executed. vuApp360 oversees crucial factors like order processing speed, real-time tracking accuracy, reliable payment transactions, accessible menu options, precise order confirmations, consistent user experience, and scalability to handle peak times. The result? A smooth and delightful experience for users, akin to having a chef meticulously crafting your order.

Optimizing E-Commerce Platforms

An e-commerce platform faces intermittent slowdowns, especially during peak hours. vuSmartMaps traces play a pivotal role by identifying specific code-level errors causing latency. This detailed insight enables the development team to swiftly optimize the application’s performance. With vuApp360, the platform not only resolves issues promptly but also ensures a seamless shopping experience for users, even during high-demand periods.

Online Trading Platform Resilience

A FinTech company providing an online trading platform relies on vuApp360 to ensure uninterrupted and real-time trading experiences. Monitoring includes order execution speed, market data retrieval, payment processing reliability, and overall system responsiveness. This guarantees traders a stable and secure platform, minimizing the risk of transaction delays or errors during crucial market moments.

Mobile Banking App Performance

In the competitive landscape of mobile banking apps, user experience is pivotal. vuApp360 focuses on monitoring the app’s responsiveness during fund transfers, account management, and transaction confirmations. It ensures that customers can seamlessly navigate the app, perform transactions swiftly, and receive real-time updates on their financial activities.

Further Reading

  1. More about the Product Capabilities of vuApp360
  2. Discover the transformative power of OpenTelemetry
  3. In-depth practitioners’ insight into OpenTelemetry


Browse through our resources to learn how you can accelerate digital transformation within your organisation.