# Application-level observability for adaptive Edge to Cloud continuum systems

Kaddour Sidi, Daniel Balouek, Baptiste Jonglez

<figure><img src="image_1.png" /></figure>

## To cite this version:

Kaddour Sidi, Daniel Balouek, Baptiste Jonglez. Application-level observability for adaptive Edge to Cloud continuum systems. UCC 2025 - IEEE/ACM 18th International Conference on Utility and Cloud Computing, Dec 2025, NANTES, France. 10.1145/3773274.3774855. hal-05371388

HAL Id: hal-05371388

https://inria.hal.science/hal-05371388v1

Submitted on 21 Jan 2026

HAL is a multi-disciplinary open access archive for the deposit and dissemination of scientific research documents, whether they are published or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

<figure><img src="image_2.png" /></figure>

Distributed under a Creative Commons CC BY 4.0 - Attribution - International License
Application-level observability
for adaptive Edge to Cloud continuum systems

Kaddour Sidi Mohammed

Daniel Balouek

Baptiste Jonglez

IMT Atlantique, Inria, LS2N

IMT Atlantique, Inria, LS2N

IMT Atlantique, Inria, LS2N

Nantes, France

Nantes, France

Nantes, France

sidi-mohammed.kaddour@inria.fr

daniel.balouek@inria.fr

baptiste.jonglez@inria.fr

Abstract

Modern Edge-to-Cloud (E2C) systems require fine-grained observ-
ability to ensure adaptive behavior and compliance with perfor-
mance objectives across heterogeneous and dynamic environments.
This work introduces an application-level observability framework
that integrates developer-driven instrumentation and SLO-aware
feedback for autonomous adaptation. By combining OpenTelemetry,
Prometheus, K3s, and Chaos Mesh, the framework enables real-time
monitoring and adaptive control across the continuum. A video pro-
cessing use case demonstrates how application-level metrics guide
automatic adjustments to maintain target frame rate, latency, and
detection accuracy under variable workloads and injected faults.
Preliminary results highlight improved scalability, fault tolerance,
and responsiveness, providing a practical foundation for adaptive,
SLO-compliant E2C applications.

Keywords

Edge-to-Cloud Continuum, Application-level Observability, Service-
Level Objectives (SLOs), Adaptive Systems, Feedback Control

ACM Reference Format:

Kaddour Sidi Mohammed, Daniel Balouek, and Baptiste Jonglez. 2025. Application-level observability for adaptive Edge to Cloud continuum systems. In *Proceedings of 18th IEEE/ACM Utility and Cloud Computing (UCC) - Inspire Workshop* (UCC ’25). ACM, New York, NY, USA, 6 pages. https://doi.org/10.1145/3773274.3774855

# 1 Introduction

Modern Edge-to-Cloud (E2C) continuum systems face significant
challenges in real-time performance management and adaptive
operation across heterogeneous and distributed resources. As high-
lighted in [4], the proliferation of billions of interconnected devices
across the planet has created a massive, interdependent “system
of systems” whose emergent behavior is difficult to predict or con-
trol. Traditional monitoring methods, which primarily focus on
infrastructure-level metrics such as CPU or memory usage, are
insufficient for capturing application-specific behaviors, including
error rates, queue lengths, or throughput. Similarly, adaptation
strategies often remain limited to coarse-grained infrastructure

actions, such as scaling replicas or allocating additional CPU re-
sources, without considering application-level metrics and actions.
Fine-grained adaptation, such as adjusting frame rates, reducing
processed frames, or switching to lighter inference models, is es-
sential for maintaining performance and quality under varying
workloads and constrained conditions.

E2C applications typically consist of multiple microservices, each
generating its own metrics and distributed traces. Collecting and an-
alyzing this data at the microservice level enables precise detection
of performance anomalies and resource bottlenecks, allowing au-
tonomous feedback mechanisms to make context-aware adaptation
decisions.

This capability is particularly important in **Urgent Computing** [3] or **time-critical computing** [12] scenarios, where services must be deployed and reconfigured rapidly without manual intervention. Examples include disaster response, emergency video analytics, and environmental monitoring, where real-time operation and adherence to performance objectives are critical despite fluctuating resources or network conditions.

Despite this need, there is a lack of open-source use cases en-
abling experimental evaluation of application-level feedback mech-
anisms in realistic E2C deployments. Existing work often focuses
on simulations or isolated components without providing an end-
to-end observable and adaptive pipeline.

To address these gaps, we introduce an **application-level ob-
servability framework for adaptive E2C continuum systems**.
Our approach integrates OpenTelemetry, Prometheus, and K3s to
collect per-microservice metrics and traces, enabling *multi-layer
adaptation* through both infrastructure and application-level ac-
tions. The framework supports *metric scalability*, allowing develop-
ers to dynamically add, remove, or redefine metrics without modi-
fying the system’s core logic. We validate our approach through
a **video surveillance use case**, demonstrating how application-
level metrics guide adaptive decisions to maintain target frame
rates, latency, and detection accuracy across heterogeneous and
time-sensitive E2C environments.

## 2 Background and Related Work

Traditional monitoring, focused on infrastructure-level metrics such as CPU and memory usage, often fails to provide the application-specific insights required for effective Edge-to-Cloud (E2C) management. This section reviews relevant background concepts and existing solutions, highlighting current gaps.

Ensuring performance objectives in E2C environments is chal-
lenging due to distribution, heterogeneous resources, and dynamic
conditions. Traditional monitoring often relies on static thresholds
and reactive responses, insufficient for real-time demands. Studies

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from permissions@acm.org.

UCC '25, Nantes, France

© 2025 Copyright held by the owner/author(s). Publication rights licensed to ACM.

ACM ISBN 978-1-4503-XXXX-X/2018/06

https://doi.org/10.1145/3773274.3774855
emphasize the need for dynamic QoS metrics and adaptive mechanisms to maintain performance [7]. Research on urgent computing scenarios also highlights adaptive systems capable of rapid deployment and reconfiguration under time-critical conditions, ensuring continuity in disaster response, emergency analytics, or environmental monitoring [5]. Adaptive systems allow applications to adjust to changing workloads, resource availability, and network conditions. Key approaches include:

**Automatic Performance Diagnosis and Recovery:** Wu [21] proposes cloud microservice systems that detect anomalies, pinpoint root causes, and recommend recovery actions without explicit instrumentation, offering insights for E2C observability.

**Intent-driven Infrastructure Adaptation:** Proteus [11] translates high-level performance intents into actionable resource configurations for Edge Sensor Nodes, demonstrating autonomous adaptation.

**Decentralized Orchestration:** Markov blanket techniques enable edge devices to infer optimal configurations while preserving QoS for video streams [18]. Integrating these into holistic feedback loops remains challenging.

**Proactive Orchestration:** ProKube [1], Tran et al. [19], and Khan et al. [6] propose proactive container scaling, migration, and consolidation. Mobile-Kube [9] and Premsankar [16] address DRL-based migration and DNN placement, highlighting trade-offs between latency, performance, and energy, though often omitting application-level metrics.

**Fault-Tolerant Edge Infrastructure:** Rasouli et al. [17] study MEC infrastructures for mission-critical IoT, using Kubernetes for self-healing and RabbitMQ for reliable messaging, ensuring continuity under node failures or network disruptions.

**Root Cause Analysis (RCA):** Sketch-based anomaly detection [14], multi-modal observability [23], dependency graphs [10], real-time anomaly propagation [22], and feature reduction [20] support RCA in cloud-edge systems [8]. However, RCA is rarely embedded in autonomous feedback loops due to computational complexity and difficulty translating outputs into adaptation actions.

Despite these advances, most approaches focus on infrastructure metrics and lack application-level observability, limiting fine-grained, real-time adaptation. Unified solutions combining multi-layer adaptation, developer-driven instrumentation, and application-level metrics remain scarce, underscoring the need for comprehensive feedback mechanisms in heterogeneous E2C environments.

# 3 Observability Driven Feedback Mechanism

Our approach targets continuum-aware applications, where microservices are distributed across edge and cloud environments. Each component produces traces and metrics that are critical for real-time monitoring and SLO compliance. By instrumenting the application code and selecting relevant metrics, the system continuously observes performance, resource usage, and event-related data.

This observability enables the feedback mechanism to detect potential SLO violations and performance anomalies as they occur. Collected metrics serve as input to automated analysis and decision-making, allowing the system to proactively adjust resources, reconfigure services, or trigger corrective actions. In this way, the

approach ensures that distributed applications remain responsive, reliable, and adaptive in dynamic Edge-to-Cloud settings.

The SLO-aware feedback mechanism continuously monitors, detects, and resolves SLO violations in Edge-to-Cloud applications. It consists of two key subprocesses operating in a real-time feedback loop: Status and Causes Inference and Reconfiguration and Resolution.

Before deployment, developers provide a descriptive configuration file defining the application's SLO objectives, relevant metrics, potential application-level actions, and interdependencies among microservices. This file serves as a declarative interface between the application and the feedback controller, enabling the system to identify measurable service-level indicators (SLIs) and their associated Service-Level Objectives (SLOs). It also specifies which adaptation levers—such as modifying frame rates, changing detection models, or adjusting resource allocations—can be applied when SLO degradation is detected. By integrating this developer-defined knowledge into the feedback loop, the mechanism ensures that monitoring and adaptation remain application-aware, context-sensitive, and aligned with the intended quality and performance objectives of the system.

## 3.1 Status and Causes Inference

This subprocess monitors application performance across edge and cloud components and detects SLO violations based on predefined thresholds. When a violation occurs, the system analyzes metrics such as processing times, response times, and resource utilization to infer root causes.

**3.1.1 Metrics Collection.** Performance metrics are collected over time t for each component c from a Time-Series Database (TSDB):

$$M_c(t) = f(c, t)$$

where f(c, t) returns the value of a specific metric. A dependency graph G = (V, E) is constructed, where V represents system components (hosts, pods, services, metrics) and E represents interactions. Dependencies are quantified as correlations:

$$R(v_1, v_2) = \text{correlation}(M_{v_1}, M_{v_2})$$

**3.1.2 Metrics Preprocessing.** Collected metrics undergo standard preprocessing:

* Cleaning and Interpolation: Handle missing values and outliers.

* Normalization: Min-Max scaling ensures metrics are comparable.

**3.1.3 Critical Metrics Extraction.** Critical metrics that impact SLO compliance, such as response times, error rates, and throughput, are identified using anomaly detection methods [15]. The system leverages the dependency graph to prioritize metrics and assess correlations between anomalies, allowing a focused analysis of the components most likely to affect overall performance.

**3.1.4 Status Inference.** The system evaluates metric conditions C = (m, op, v) to determine overall status:

$$\text{status} = \begin{cases} \text{good} & \text{if all conditions are satisfied} \\ \text{fail} & \text{otherwise} \end{cases}$$
<figure><img src="image_3.png" /><figcaption>Figure 1: Feedback Mechanism Scheme</figcaption></figure>

This allows real-time detection of SLO violations and identification of components likely responsible.

## 3.2 Reconfiguration and Resolution

Upon identifying the root cause, the system autonomously adjusts parameters to restore SLO compliance. Actions may include re-source scaling, load redistribution, workflow optimization, or alternative processing paths. These adjustments ensure system responsiveness, maintain service quality, and operate effectively in time-critical, urgent computing contexts with minimal human intervention.

3.2.1 **Action Inference.** Based on inferred status and root causes, appropriate actions are determined. These actions are categorized into two main types: infrastructure-level (e.g., scaling K3s pods via Kubernetes HPA, adjusting resource limits) and application-level (e.g., dynamically lowering video frame rates, switching to a lighter object detection model, or modifying processing queues). The inference is guided by a predefined set of actions within the descriptive configuration file, which maps specific SLO violations and root causes to a prioritized list of corrective measures.

3.2.2 **Reconfiguration.** After actions are inferred, they are applied to the system. K3s is utilized to reconfigure application or infrastructure components according to the inferred actions. For instance, if an SLO violation is traced to high CPU usage on an edge node, K3s might scale out the affected microservice. If the issue is application-specific, such as high response time in video processing, the system might command the video processing microservice to reduce its frame sampling rate.

3.2.3 **Evaluation.** Following reconfiguration, the impact of applied actions on critical metrics and SLO compliance is continuously monitored. This evaluation ensures that the corrective measures are effective and identifies any remaining or emerging performance degradations.

3.2.4 **Knowledge Database.** To enhance adaptive capabilities, a knowledge database stores historical data on SLO violations, their inferred root causes, and the effectiveness of applied actions. This

repository informs future adaptations, allowing the system to learn optimal responses over time and refine its decision-making process through reinforcement learning techniques (planned for future work).

## 3.3 Novelty in Application-Specific Metrics and Developer-Driven Instrumentation

Our approach emphasizes **application-specific metrics** and **developer-driven instrumentation**. Unlike traditional monitoring, which relies on generic infrastructure metrics, developers define and instrument metrics reflecting functional and nonfunctional requirements. By integrating OpenTelemetry from the development phase, telemetry data is context-rich, enabling precise root cause analysis and targeted optimization.

# 4 Evaluation

## 4.1 Use Case: Video Processing Application

The surveillance system, previously introduced in our earlier work [13], is a distributed Edge-to-Cloud architecture designed to process video feeds and identify dangerous animals, ensuring timely alerts for residents and authorities. It comprises the following key components,

**Camera:** Captures video frames, resizes them for efficient processing, and transmits them to the motion detection module.

**Motion Detection:** Operates at the edge, analyzing video frames for motion and forwarding relevant frames to the object recognition module.

**Object Recognizer:** Uses the YOLO model for object classification and detection. It operates in the cloud and processes frames asynchronously.

Figure 2 shows the flow from edge cameras to cloud object recognition.

The application leverages OpenTelemetry to collect and send application-level metrics for the feedback mechanism.

This application is open-source and available at https://gitlab.inria.fr/STACK-RESEARCH-GROUP/software/edge-to-cloud-video-processing.git.
<figure><img src="image_4.png" /><figcaption>Figure 2: Overview of the Edge-to-Cloud Use-Case</figcaption></figure>

## 4.2 Setup

<figure><img src="image_5.png" /><figcaption>Figure 3: Observability Workflow for the Use-Case Application on Grid5000</figcaption></figure>

We deployed a preliminary experimental environment on Grid'5000 [2] to evaluate our SLO-aware feedback mechanism. The setup uses several nodes (G5K virtual machines) with K3s (via EnOSlib) simulating camera, edge, and cloud environments. Camera nodes are lightweight devices with 1 CPU core and 1 GB RAM, responsible for generating and transmitting video frames. Edge nodes have 4 CPU cores, 8 GB RAM, and 1 Gbps connectivity, while cloud nodes have 8 CPU cores, 16 GB RAM, and 10 Gbps connectivity. OpenTelemetry collects application traces and custom metrics (e.g., frame processing time, detection accuracy), exported to Prometheus.

K3s tools (cAdvisor, Node Exporter) monitor CPU, memory, and network usage. Chaos Mesh injects faults (e.g., network latency, CPU pressure) to test resilience and adaptation.

<table><caption>Table 1: Grid'5000 Experimental Hardware Setup</caption><thead><tr><td>Component</td><td>Specs</td></tr></thead><tbody><tr><td>Camera Nodes</td><td>1 CPU, 1 GB RAM</td></tr><tr><td>Edge Nodes</td><td>4 CPU, 8 GB RAM</td></tr><tr><td>Cloud Nodes</td><td>8 CPU, 16 GB RAM</td></tr></tbody></table>

<table><caption>Table 2: Metrics Collected by Tools and Their Nature</caption><thead><tr><td>Tool</td><td>Metric level</td></tr></thead><tbody><tr><td>OpenTelemetry</td><td>Application (frame rate, processing time, accuracy)</td></tr><tr><td>cAdvisor</td><td>Infrastructure (CPU usage, container stats)</td></tr><tr><td>Node Exporter</td><td>Infrastructure (CPU load, memory, network I/O)</td></tr></tbody></table>

## 4.3 Results

We present results from two complementary evaluations: one assessing system scalability as the number of cameras and motion detectors increases, and another examining the impact of application-level metrics, such as animal appearance rates, on system response times. These experiments illustrate the system's behavior under varying workloads and metric conditions.

### 4.3.1 Scalability.
Figure 4 illustrates that our feedback mechanism adapts seamlessly to system growth and evolving monitoring needs. When the video surveillance system scales out by adding three cameras and three motion detectors, the mechanism dynamically adjusts the allocation of resources, maintaining stable processing times. The strong correlation observed between metrics, processing time, and pod scaling confirms efficient adaptation and resource utilization. Furthermore, our approach supports *metric scalability*: developers can add, remove, or modify monitored metrics at runtime without disrupting operation or requiring code changes. This dual scalability—both at the system and metric levels—demonstrates the robustness, flexibility, and practicality of our feedback mechanism for real-world Edge-to-Cloud monitoring scenarios.

### 4.3.2 Applicative Metrics Inclusion.
Applicative metrics provide valuable insights into system behavior, enabling optimizations beyond infrastructure-level monitoring. In this context, we define the APPEARANCE_RATE (AR) as the expected number of times an animal appears per hour in a simulated footage. The response time of the object recognizer is directly influenced by the number of detected motions.
<figure><img src="image_6.png" /><figcaption>Figure 4: System evolution over time showing processing time, metrics, and pod count; the scale-out window indicates adaptive resource adjustment under load.</figcaption></figure>

<figure><img src="image_7.png" /><figcaption>Figure 5: Detected motions vs response time (AR: 05, 05, 05)</figcaption></figure>

At low appearance rates (AR: 05, 05, 05), as shown in Figure 5, the system maintains stable response times, indicating efficient processing under light workloads.

<figure><img src="image_8.png" /><figcaption>Figure 7: Detected motions vs response time (AR: 30, 30, 30)</figcaption></figure>

Finally, under high appearance rates (AR: 30, 30, 30) shown in Figure 7, the response time increases significantly due to the higher number of detected motions. In such conditions, the system can dynamically reduce the sampling rate to maintain stability and prevent overload.

## 5 Discussion

This work demonstrates the potential of application-level observability combined with performance-aware feedback for adaptive Edge-to-Cloud (E2C) systems. By leveraging developer-driven instrumentation, OpenTelemetry, Prometheus, K3s, and Chaos Mesh, the proposed framework enables real-time monitoring and autonomous adaptation across heterogeneous and dynamic environments.

The preliminary results from the video processing use case illustrate how application-specific metrics, such as frame processing time and object appearance rates, guide adaptive actions. These actions include adjusting the frame rate, reducing the number of processed frames, or switching to a lighter detection model, ensuring that target performance objectives—such as latency, frame rate, and detection accuracy—are maintained even under variable workloads and injected faults.

The framework's support for multi-layer adaptation, encompassing both infrastructure and application-level actions, highlights its

<figure><img src="image_9.png" /><figcaption>Figure 6: Detected motions vs response time (AR: 05, 10, 15)</figcaption></figure>

When the motion frequency increases and becomes unbalanced (AR: 05, 10, 15), as shown in Figure 6, response times vary according to the motion density in each camera stream, revealing the sensitivity of the object recognizer to fluctuating workloads.
capacity to maintain compliance with defined performance objectives while efficiently utilizing available resources. Furthermore, the ability to dynamically add, remove, or redefine metrics without code changes demonstrates the flexibility and scalability of the approach in evolving E2C environments.

Overall, the study provides evidence that fine-grained, application-level observability enables more precise and context-aware adaptation than traditional infrastructure-centric monitoring. These insights lay a practical foundation for developing resilient, performance-compliant, and self-adaptive E2C applications.

## 5.1 Future Directions

Our future work revolves around enhancing the automated configuration of microservice dependencies and adaptation rules for E2C applications. Future work will explore SLO enforcement through three key directions: (i) a comprehensive experimental validation for scalability and SLO compliance, (ii) machine learning-driven adaptation to predict SLO violations, and (iii) automated metric discovery and management.

## 6 Conclusion

In this paper, we introduced an application-level observability framework for adaptive Edge-to-Cloud (E2C) continuum systems. The approach leverages developer driven instrumentation and application-specific metrics to enable real-time monitoring, analysis, and self-adaptation across heterogeneous environments. By combining tools such as OpenTelemetry, Prometheus, K3s, and Chaos Mesh, the system achieves continuous observability and responsive adaptation.

The video processing use case demonstrated how application-level insights improve resilience, scalability, and responsiveness under dynamic workloads and fault conditions. This work establishes a foundation for autonomously managed continuum applications and paves the way toward intelligent, self-optimizing systems that reduce operational complexity while enhancing reliability and performance.

## Acknowledgments

This research was supported by two projects: the French project *OTPaaS* funded by Bpifrance, and the **QUICK - Urgent Computing across the Edge-Cloud Continuum** project, funded by the Etoiles Montantes program - Région Pays de la Loire, France.

## References

[1] Babar el al. Ali. 2025. ProKube: Proactive Kubernetes Orchestrator for Inference in Heterogeneous Edge Computing. *International Journal of Network Management* 35, 1 (2025), e2298. doi:10.1002/nem.2298 e2298 nem.2298.

[2] Daniel Balouek, Alexandra Carpen Amarie, Ghislain Charrier, Frédéric Desprez, Emmanuel Jeannot, Emmanuel Jeanvoine, Adrien Lèbre, David Margery, Nicolas Niclausse, Lucas Nussbaum, Olivier Richard, Christian Perez, Flavien Quesnel, Cyril Rohr, and Luc Sarzyniec. 2012. Adding virtualization capabilities to the Grid'5000 testbed. In *International Conference on Cloud Computing and Services Science*, Ivan I. Ivanov, Marten van Sinderen, Frank Leymann, and Tony Shan (Eds.). Springer, 3-20. doi:10.1007/978-3-319-04519-1_1

[3] Daniel Balouek-Thomert, Ivan Rodero, and Manish Parashar. 2020. Harnessing the Computing Continuum for Urgent Science. *SIGMETRICS Perform. Eval. Rev.* 48, 2 (Nov. 2020), 41-46. doi:10.1145/3439602.3439618

[4] Pete et al. Beckman. 2020. Harnessing the Computing Continuum for Programming Our World. *Fog Computing* (2020). doi:10.1002/9781119551713.ch7

[5] Patrizio et al. Dazzi. 2024. Urgent Edge Computing. In *Proceedings of the 4th Workshop on Flexible Resource and Application Management on the Edge* (Pisa, Italy) (FRAME '24). Association for Computing Machinery, New York, NY, USA, 7-14. doi:10.1145/3659994.3660315

[6] Ayaz Ali Khan et al. 2020. An Energy, Performance Efficient Resource Consolidation Scheme for Heterogeneous Cloud Datacenters. *Future Generation Computer Systems* 108 (2020), 123-135. doi:10.1016/j.jnca.2019.102497

[7] Amaury Sauret et al. 2025. A Survey on Dynamic SLAs for Fog Computing. *Authorea Preprints* (2025). doi:10.22541/au.174855437.71710419/v1

[8] Yuhan Zhu et al. 2024. Root Cause Localization for Microservice Systems in Cloud-edge Collaborative Environments. http://arxiv.org/abs/2406.13604 arXiv:2406.13604 [cs].

[9] Saeid et al. Ghafouri. 2022. Mobile-Kube: Mobility-aware and Energy-efficient Service Orchestration on Kubernetes Edge Servers. In *2022 IEEE/ACM 15th International Conference on Utility and Cloud Computing* (UCC). 82-91. doi:10.1109/UCC56403.2022.00019

[10] Chuanjia et al. Hou. 2021. Diagnosing Performance Issues in Microservices with Heterogeneous Data Source. In *2021 IEEE Intl Conf on Parallel & Distributed Processing with Applications, Big Data & Cloud Computing, Sustainable Computing & Communications, Social Computing & Networking (ISPA/BDCloud/SocialCom/SustainCom)*. IEEE, New York City, NY, USA, 493-500. doi:10.1109/ISPA-BDCloud-SocialCom-SustainCom52081.2021.00074

[11] Shashikant Ilager, Daniel Balouek, Sidi Mohammed Kaddour, and Ivona Brandic. 2024. Proteus: Towards Intent-driven Automated Resource Management Framework for Edge Sensor Nodes. In *Proceedings of the 14th Workshop on AI and Scientific Computing at Scale Using Flexible Computing Infrastructures* (Pisa, Italy) (FlexScience'24). Association for Computing Machinery, New York, NY, USA, 1-8. doi:10.1145/3659995.3660037

[12] Arpit Jain and Dharm Singh Jat. 2020. An Edge Computing Paradigm for Time-Sensitive Applications. In *2020 Fourth World Conference on Smart Trends in Systems, Security and Sustainability (WorldS4)*. 798-803. doi:10.1109/WorldS450073. 2020.9210325

[13] Baptiste Jonglez, Matthieu Simonin, Jolan Philippe, and Sidi Mohammed Kaddour. 2025. Multi-provider Capabilities in EnOSlib: Driving Distributed System Experiments on the Edge-to-Cloud Continuum. In *Distributed Applications and Interoperable Systems* (Lille, France). Springer-Verlag, Berlin, Heidelberg, 25-42. doi:10.1007/978-3-031-95728-4_2

[14] Yufeng et al. Li. 2022. MicroSketch: Lightweight and Adaptive Sketch Based Performance Issue Detection and Localization in Microservice Systems. In *Service-Oriented Computing*, Javier Troya, Brahim Medjahed, Mario Piattini, Lina Yao, Pablo Fernández, and Antonio Ruiz-Cortés (Eds.). Vol. 13740. Springer Nature Switzerland, Cham, 219-236. doi:10.1007/978-3-031-20984-0_15 Series Title: Lecture Notes in Computer Science.

[15] Fei Tony et al. Liu. 2008. Isolation Forest. In *2008 Eighth IEEE International Conference on Data Mining*. 413-422. doi:10.1109/ICDM.2008.17

[16] Gopika Prem sankar and Bissan Ghaddar. 2022. Energy-Efficient Service Placement for Latency-Sensitive Applications in Edge Computing. *IEEE Internet of Things Journal* 9, 18 (2022), 17926-17937. doi:10.1109/IIOT.2022.3162581

[17] Nayereh Rasouli, Cristian Klein, and Erik Elmothro. 2024. Fault Tolerance Infrastructure for Mission-Critical Mobile Edge Cloud Applications. In *2024 IEEE/ACM 17th International Conference on Utility and Cloud Computing* (UCC). 382-388. doi:10.1109/UCC63386.2024.00059

[18] Boris el al. Sedlak. 2023. Designing Reconfigurable Intelligent Systems with Markov Blankets. In *Service-Oriented Computing*, Flavia Monti, Stefanie Rinderle-Ma, Antonio Ruiz Cortés, Zibin Zheng, and Massimo Mecella (Eds.). Vol. 14419. Springer Nature Switzerland, Cham, 42-50. doi:10.1007/978-3-031-48421-6_4 Series Title: Lecture Notes in Computer Science.

[19] Minh-Ngoc el al. Tran. 2022. Proactive Stateful Fault-Tolerant System for Kubernetes Containerized Services. *IEEE Access* 10 (2022), 12345-12356.

[20] Yuuki Tsubouchi and Hirofumi Tsuruta. 2024. MetricSifter: Feature Reduction of Multivariate Time Series Data for Efficient Fault Localization in Cloud Applications. *IEEE Access* 12 (2024), 37398-37417. doi:10.1109/ACCESS.2024.3374334

[21] Li Wu. 2022. *Automatic Performance Diagnosis and Recovery in Cloud Microservices*. Ph. D. Dissertation. Advisor(s) Markus, Brill, and Odej, Kao, and Johan, Tordsson, and Guillaume, Pierre. AAI29289472.

[22] Li et al. Wu. 2020. MicroRCA: Root Cause Localization of Performance Issues in Microservices. In *NOMS 2020 - 2020 IEEE/IFIP Network Operations and Management Symposium*. IEEE, Budapest, Hungary, 1-9. doi:10.1109/NOMS47738.2020.9110353

[23] Guangba et al. Yu. 2023. Nezha: Interpretable Fine-Grained Root Causes Analysis for Microservices on Multi-modal Observability Data. In *Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering* (San Francisco, CA, USA) (ESEC/FSE 2023). Association for Computing Machinery, New York, NY, USA, 553-565. doi:10.1145/3611643.3616249