Service Extraction from Monolithic Applications via Runtime Tracing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing applications without a service-oriented design face challenges in extracting services to transition to a service-oriented architecture, as they often have monolithic functionality and lack modular design, making it difficult to leverage core services across applications.
Innovation Solution
A service extraction and application composition system that preprocesses and instruments existing applications to convert them into a service-oriented architecture, using REST-based APIs to generate refactored code and create a service-oriented prototype application, allowing for the extraction, refinement, and deployment of services.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If services are extracted from existing monolithic applications, then service reusability and resource utilization improve, but application complexity and extraction difficulty increase
Solution Approach 1:
The patent segments monolithic applications into discrete, reusable services by identifying service boundaries through static code analysis and runtime behavior tracing. The system divides application functionality into independent service units that can be extracted and reused across different applications, transforming a single large application into multiple smaller, manageable service components.
Solution Approach 2:
The patent extracts services from existing applications by analyzing code structure and runtime behavior to identify service boundaries. The extraction process separates service logic from the original application monolith, creating standalone service components that can be independently deployed and reused, while the original application continues to function with reduced functionality.
2Manufacturing precision
If static code analysis is used to identify services, then extraction precision improves, but detection of runtime behavior limitations increase
Solution Approach 1:
The patent merges static code analysis with runtime behavior tracing to overcome the limitations of each individual approach. The system first performs static analysis to identify potential service boundaries based on code structure, then uses runtime tracing to validate and refine these boundaries by observing actual service invocation patterns and behavior, combining both methods for accurate service extraction.
Solution Approach 2:
The patent introduces an intermediary tracing mechanism that instruments the application code to capture runtime behavior without significantly altering the original application. This intermediary layer records service invocations, parameters, and return values, providing data that bridges the gap between static code analysis and actual runtime behavior, enabling more accurate service identification.
3Measurement precision
If instrumentation code is injected into existing applications, then service behavior tracing accuracy improves, but application modification complexity increases
Solution Approach 1:
The patent performs preliminary actions by automatically injecting instrumentation code into the application during the service extraction process, before runtime tracing begins. The system prepares the application by inserting tracing hooks at identified service boundaries, so that when runtime tracing occurs, the instrumentation is already in place to capture accurate service behavior without requiring manual modification during the tracing phase.
Data Source
AI summary
Service extraction and application composition may include preprocessing and instrumenting an existing application that is to be converted to a service-oriented application. The existing application may be executed to generate traces related to a runtime behavior of services related to the existing application. The traces may be used to generate calling code related to the services related to the existing application. Representational state transfer (REST) application programming interfaces (APIs) that include the calling code to call the services related to the existing application may be generated. Refactored code for the existing application may be generated for invocation of the services related to the existing application by the REST APIs.