# Vnode: Low-Overhead Transparent Tracing of Node.js-Based Microservice Architectures
## 1 Introduction  
The swift advancement of technology has propelled the widespread adoption of microservice architectures, which highlight key aspects like availability, resilience, fault tolerance, and enhanced collaboration among teams. In such an architecture, each component operates independently and communicates through efficient, lightweight protocols. These architectures are highly favored due to their facilitation of collaborative efforts and their capability to meet modern challenges in application design, development, maintenance, and deployment [1]. They bolster the system's resilience, effectively manage failures, and seamlessly adapt to scaling requirements. Nonetheless, these advantages come with certain challenges, particularly due to the heterogeneity of the components, issues in service allocation, and notably, concerns regarding overall system performance [2]. Debugging issues in microservice architectures poses significant difficulties. System malfunctions can compromise the user experience, and identifying the root cause of these issues can be difficult based on the information at hand. Even with error indications from protocol headers like HTTP, the process of diagnosing issues can be challenging. Additionally, arranging the components in a way that maintains system attributes such as availability and low latency introduces intricacies [3; 4]. The challenges of debugging [5; 6; 7; 8; 9] and component arrangement [10] have been addressed through the implementation of distributed tracing techniques [11; 12; 13; 14; 15; 16; 17; 18]. However, applying these methods necessitates instrumenting the application's source code, which brings additional overhead and the risk of altering the application's behavior. Other strategies extend instrumentation to dependencies to minimize changes at the application level. Transparent tracing, in contrast to distributed tracing, allows for the collection of system telemetry data without the need for a prior instrumentation phase. Therefore, developers are not required to modify the application's source code to insert trace points. On the other hand, tracing a system incurs an additional cost, which must be considered by any collection approach. Developing tracing methods that have a minimal impact on the system is necessary for applications where performance is a primary requirement. Although overhead issues have partly been addressed through sampling methods [19; 20], both approaches to instrumentation present challenges. Instrumenting at the dependency level may fail to capture internal application logic issues like bugs, whereas instrumenting the application's source code could potentially alter its functioning. Both methods entail modifications to the application, necessitating human effort and incurring extra costs. The burden of instrumentation efforts has led to the development of strategies aimed at reducing these costs across several research domains [21; 22]. In the context of microservices, this issue has recently been addressed by advocating for the use of proxies [PERSON] et al. [23] as an intermediary layer for transparent tracing. However, while this spares the application from source code modifications, it shifts the burden to setting up and configuring the proxies. Additionally, their operation involves intercepting system calls to insert trace contexts into requests, which can be problematic in public clouds where kernel access might be restricted. We propose an innovative approach for tracing and debugging microservices in the Node.js environment, which is designed to address the limitations of existing methods while ensuring full transparency. This approach distinguishes itself in two key areas: (1) it obviates the need for developers to invest effort in establishing a collection infrastructure that includes instrumentation, and (2) it transparently analyzes collected traces, leading to visualization tools that map the interactions among microservices, thereby enabling the debugging of performance issues in a completely transparent manner.