Runtime Dependency Graphs for Microservices Anomaly Detection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing microservices platforms face challenges in identifying design anomalies and anti-patterns due to the complexity of distributed codebases and the impracticality of static code analysis, especially when access to source code is limited.
Innovation Solution
A dynamic analysis methodology that leverages observability systems to generate a dependency graph based on run-time execution data, using neural subgraph matching and graph embeddings to identify anomalies and anti-patterns.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If static code analysis is used to identify design anomalies, then comprehensive code inspection is possible, but access to source code is required and the process becomes impractical for distributed codebases
Solution Approach 1:
The patent uses runtime execution data as an intermediary to indirectly analyze code dependencies without requiring direct access to source code. Instead of statically analyzing code, the system observes actual runtime behavior, calls, and interactions to reconstruct dependency graphs and detect anomalies, thus avoiding the operational complexity of source code access while maintaining detection capability
Solution Approach 2:
The patent replaces the mechanical process of static code analysis with a dynamic observation-based system. Instead of mechanically parsing and analyzing source code structure, the system substitutes this with automated collection and analysis of runtime execution traces, call graphs, and interaction data to achieve anomaly detection without direct code access
2Adaptability or versatility
If dynamic analysis with runtime execution data is used, then source code access is not required, but the complexity of processing and analyzing runtime data increases
Solution Approach 1:
The patent segments the complex runtime data processing into distinct components: collecting execution traces, constructing call graphs, generating dependency graphs, and performing anomaly detection. This segmentation breaks down the overwhelming complexity of processing raw runtime data into manageable, modular stages that can be handled by specialized subsystems
Solution Approach 2:
The patent introduces intermediate data structures such as call graphs and dependency graphs that serve as mediators between raw runtime execution data and anomaly detection algorithms. These intermediate representations simplify the complex runtime data into structured formats that are easier to analyze while preserving the essential information needed for anomaly detection
3Measurement precision
If comprehensive dependency graph analysis is performed, then anomaly detection accuracy improves, but processing time and computational resources increase
Solution Approach 1:
The patent performs preliminary actions by continuously collecting and preprocessing runtime execution data during normal system operation. Dependency graphs are constructed and maintained in advance, so when anomaly detection is needed, the analysis can be performed quickly on pre-processed data rather than starting from scratch, reducing the time loss for detection operations
Solution Approach 2:
The patent applies partial analysis by focusing computational resources on detecting specific types of anomalies or analyzing only relevant portions of the dependency graph. Instead of performing exhaustive analysis on the entire system simultaneously, the system can selectively analyze specific service components or dependency paths, reducing overall processing time while maintaining detection accuracy for critical areas
Data Source
AI summary
Architectures and techniques are described that can generate or receive a dependency graph of a microservices platform. The dependency graph can be constructed based on run time operation of microservices such that the nodes of the graph can represent microservices and the edges can represent the interactions during run time. The dependency graph along with an anomaly pattern can be embedded into an embedding space, and based on an examination of the embedding space, it can be determined whether the anomaly pattern exists in the dependency graph.