Creating Microservices from Monolithic Applications Based on Runtime Traces

Abstract

Microservice generation from a monolithic application based on runtime traces. A system, computer-implemented method, and computer program product for generating microservices from a monolithic application based on runtime traces are provided. According to an embodiment, the system includes a memory storing computer-executable components and a processor executing the computer-executable components stored in the memory. The computer-executable components may include a model component that learns cluster assignments for classes in the monolithic application based on runtime traces of executed test cases. The computer-executable components may further include a cluster component that uses the model component to generate clusters of classes based on the cluster assignments to identify one or more microservices in the monolithic application.

Description

[Background technology]

[0001] The present invention relates to generating microservices from a monolithic application, and more particularly to generating microservices from a monolithic application based on runtime tracing. Summary of the Invention

[0002] The following provides a summary to provide a basis for understanding one or more embodiments of the present invention. This summary is not intended to identify key or critical elements or to delineate any scope of particular embodiments or any scope of the claims. Its sole purpose is to present concepts in a simplified form without precluding what is described in more detailed below. In one or more embodiments described herein, a system, device, computer-implemented method, or computer program product, or combination thereof, that facilitates generating microservices from a monolithic application based on runtime tracing is described.

[0003] According to an embodiment, a system may include a memory storing computer-executable components and a processor executing the computer-executable components stored in the memory. The computer-executable components may include a model component that learns cluster assignments of classes in a monolithic application based on runtime traces of executed test cases. The computer-executable components may further include a cluster component that uses the model component to generate clusters of the classes based on the cluster assignments to identify one or more microservices of the monolithic application. A benefit of such a system is that it may facilitate improved functional grouping of classes (e.g., functional clustering) to enable more accurate identification of one or more microservices and improved application modernization of a monolithic application.

[0004] In some embodiments, the executed test cases include business functionality test cases that provide a business functionality of the monolithic application in the runtime trace. A benefit of such a system is that it can facilitate improved functional grouping of classes (e.g., functional clustering) to enable more accurate identification of one or more microservices and improved application modernization of a monolithic application.

[0005] According to another embodiment, the computer-implemented method may include training, by a system operatively coupled to a processor, a model to learn cluster assignments of classes in a monolithic application based on runtime traces of executed test cases. The computer-implemented method may further include, by the system, utilizing the model to generate clusters of the classes based on the cluster assignments to identify one or more microservices of the monolithic application. A benefit of such a system is that it may facilitate improved functional grouping of classes (e.g., functional clustering) to enable more accurate identification of one or more microservices and improved application modernization of the monolithic application.

[0006] In some embodiments, the executed test cases may include business functionality test cases that provide a business functionality of the monolithic application in the runtime trace. An advantage of such a computer-implemented method is that it may facilitate improved functional grouping (e.g., functional clustering) of classes to enable more accurate identification of one or more microservices and improved application modernization of a monolithic application.

[0007] According to another embodiment, a computer program product is provided for facilitating generation of microservices from a monolithic application based on runtime traces. The computer program product includes a computer-readable storage medium having program instructions embodied therein, the program instructions being executable by a processor to cause the processor to train a model to learn cluster assignments of classes in a monolithic application based on runtime traces of executed test cases. The program instructions further cause the processor to utilize the model to generate clusters of the classes based on the cluster assignments to identify one or more microservices of the monolithic application. An advantage of such a computer program product is that it can facilitate improved functional grouping of classes (e.g., functional clustering) to enable more accurate identification of one or more microservices and improved application modernization of a monolithic application.

[0008] In some embodiments, the executed test cases include business functionality test cases that provide a business functionality of the monolithic application in the runtime trace. An advantage of such a computer program product is that it can facilitate improved functional grouping (e.g., functional clustering) of classes to enable more accurate identification of one or more microservices and improved application modernization of a monolithic application.

[0009] According to an embodiment, a system may include a memory storing computer-executable components and a processor executing the computer-executable components stored in the memory. The computer-executable components may further include a collection component that collects runtime traces of test cases executed on the monolithic application. The computer-executable components may further include a model component that learns cluster assignments of classes in the monolithic application based on the runtime traces of the executed test cases. The computer-executable components may further include a cluster component that utilizes the model component to generate clusters of the classes based on the cluster assignments to identify one or more microservices of the monolithic application. An advantage of such a computer program product is that it may facilitate improved functional grouping of classes (e.g., functional clustering) to enable more accurate identification of one or more microservices and improved application modernization of the monolithic application.

[0010] In some embodiments, the test cases include business functionality test cases that provide business functionality of the monolithic application in the runtime trace. An advantage of such a computer program product is that it can facilitate improved functional grouping (e.g., functional clustering) of classes to enable more accurate identification of one or more microservices and improved application modernization of a monolithic application.

[0011] According to another embodiment, a computer-implemented method may include collecting, by a system operatively coupled to a processor, runtime traces of test cases executed on a monolithic application. The computer-implemented method may further include training, by the system, a model to learn cluster assignments of classes in the monolithic application based on the runtime traces of the executed test cases. The computer-implemented method may further include generating, by the system, clusters of the classes based on the cluster assignments to identify one or more microservices of the monolithic application using the model. An advantage of such a computer program product is that it may facilitate improved functional grouping (e.g., functional clustering) of classes to enable more accurate identification of one or more microservices and improved application modernization of the monolithic application.

[0012] In some embodiments, the test cases include business functionality test cases that provide a business functionality of the monolithic application in the runtime trace. An advantage of such a computer program product is that it can facilitate improved functional grouping (e.g., functional clustering) of classes to enable more accurate identification of one or more microservices and improved application modernization of a monolithic application. [Brief description of the drawings]

[0013] [Figure 1] FIG. 1 illustrates a block diagram of an example non-limiting system that can facilitate generation of microservices from a monolithic application based on runtime tracing, in accordance with one or more embodiments described herein. [Diagram 2]FIG. 2 illustrates a block diagram of an example non-limiting system that can facilitate generation of microservices from a monolithic application based on runtime tracing, in accordance with one or more embodiments described herein. [Diagram 3] FIG. 3 illustrates a flow diagram of an example non-limiting computer-implemented method that can facilitate generation of microservices from a monolithic application based on runtime tracing, in accordance with one or more embodiments described herein. [Figure 4] FIG. 4 illustrates a block diagram of an example non-limiting model that can facilitate generation of microservices from a monolithic application based on runtime tracing, in accordance with one or more embodiments described herein. [Diagram 5] FIG. 5 illustrates a flow diagram of an example non-limiting computer-implemented method that can facilitate generation of microservices from a monolithic application based on runtime tracing, in accordance with one or more embodiments described herein. [Figure 6] FIG. 6 illustrates a flow diagram of an example non-limiting computer-implemented method that can facilitate generation of microservices from a monolithic application based on runtime tracing, in accordance with one or more embodiments described herein. [Figure 7] FIG. 7 illustrates a flow diagram of an example non-limiting computer-implemented method that can facilitate generation of microservices from a monolithic application based on runtime tracing, in accordance with one or more embodiments described herein. [Figure 8] FIG. 8 illustrates a block diagram of an example non-limiting operating environment capable of facilitating one or more embodiments described herein. [Figure 9] FIG. 9 illustrates a non-limiting block diagram of an example cloud computing environment in accordance with one or more embodiments of the present invention. [Figure 10] FIG. 10 illustrates a non-limiting block diagram of an example of an abstract model layer in accordance with one or more embodiments of the present invention. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0014] The following detailed description is merely illustrative and is not intended to limit the scope of the embodiments, or the application or both, or the uses of the embodiments, nor is it intended to be bound by any express or implied information presented in the preceding Background or Summary sections or within the Detailed Description of the Invention.

[0015] One or more embodiments are now described with reference to the drawings, wherein like reference numerals are used to refer to like elements throughout. In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a more thorough understanding of one or more embodiments. It will be apparent, however, that in various instances, one or more embodiments may be practiced without these specific details.

[0016] Application modernization is the process of refactoring monolith applications (also referred to as monolithic applications) into standalone microservices. Traditional monolith enterprise applications are designed with complex and intertwined representations, business processes, and data models that are difficult to maintain and change. Microservices are loosely coupled, standalone applications that encapsulate a small set of functionality and interact with other applications through publicly described interfaces. They are therefore easier to update, scale, maintain, and deploy in cloud computing environments.

[0017] Some existing application modernization techniques apply static code analysis based approaches to generate microservices from monolithic applications. Such static code analysis based approaches analyze the source to provide a complete view of the call relationships. The problem with such static code analysis based approaches is that they do not capture the call relationships and interaction frequencies under specific workloads and inputs.

[0018] Some existing application modernization techniques apply a metadata-based approach to generate microservices from monolithic applications. Such metadata-based approaches rely on design documents, e.g., data flow diagrams, software artifacts, code base change histories, or other design documents or a combination of these. The problem with such metadata-based approaches is that design documents as defined above are not always available and accessible.

[0019] Some existing application modernization techniques apply a dynamic microservices composition-based approach to generate microservices from monolithic applications. Such dynamic microservices composition-based approaches use operational data and generate a microservices model that is dynamically adapted during runtime. The problem with such dynamic microservices composition-based approaches is that operational data is difficult to collect.

[0020] Some existing application modernization techniques apply a workload data-based approach to generate microservices from monolithic applications. Such workload data-based approaches use operational data (e.g., log files) and generate a fixed microservices model after data collection. The problem with such workload data-based approaches is that operational data is difficult to collect.

[0021] Some existing application modernization techniques apply an approach that uses runtime traces to learn class groupings by implementing the following steps: 1) assigning all classes to different clusters; 2) calculating the Jaccard similarity coefficient for each pair of clusters, where the clusters with maximum Jaccard similarity are merged; and 3) applying a generative algorithm to refine the results according to some optimal objective (e.g., maximizing internal connectivity and minimizing external connectivity). The problem with such an approach is that it does not consider the essential business context in generating grouping classes that have good business function binding. Another problem with such an approach is that it does not consider higher order temporal dependencies. Another problem with such an approach is that it aggregates run traces into a graph, thus losing valuable temporal information and assuming incorrect transitive relationships. Another problem with such an approach is that it does not directly minimize the invocation volume and does not minimize the business context to improve the cluster quality.

[0022] Given the above-mentioned problems with existing application modernization techniques, the present disclosure may be implemented to generate solutions to these problems in the form of a system, computer-implemented method, or computer program product, or combinations thereof, which may train a model to learn a graph embedding of classes or cluster assignments in a monolithic application based on a runtime trace of test cases that may be executed using the monolithic application; or may generate a graph embedding for identifying one or more clusters of classes or monolithic applications based on the cluster assignments utilizing the model, or combinations thereof. An advantage of such a system, computer-implemented method, or computer program product, or combinations thereof, is that they may be implemented to facilitate functional grouping of classes (e.g., functional clustering) to enable accurate identification of one or more microservices and improved application modernization of the monolithic application. In some embodiments, the test cases may include business functionality test cases that provide the business functionality of the monolithic application in the runtime trace. An advantage of such a system, computer-implemented method, or computer program product, or combination thereof, which may be implemented to facilitate functional grouping of classes (e.g., functional clustering), is that they enable accurate identification of one or more microservices and improved application modernization of monolithic applications.

[0023] 1 illustrates a block diagram of an example non-limiting system 100 that can facilitate generation of microservices from a monolithic application based on runtime traces, according to one or more embodiments described herein. The system 100 can include a microservice generation system 102, which can be associated with a cloud computing environment. For example, the microservice generation system 102 can be associated with the cloud computing environment 950 described below with reference to FIG. 9 or one or more functional abstraction layers described below with reference to FIG. 10 (e.g., hardware and software layer 1060, visualization layer 1070, management layer 1080, or workload layer 1090, or a combination thereof), or both.

[0024] The microservice generation system 102 or components thereof, or combinations thereof (e.g., the model component 108, the cluster component 110, the collection component 202, the second model component 204, the refinement component 206, etc.) may use a cloud computing environment 950, described below with reference to FIG. 9, or one or more functional abstraction layers, described below with reference to FIG. 10, (e.g., quantum software, etc.) to perform one or more operations according to one or more embodiments of the invention described herein. For example, the cloud computing environment 950 or such one or more functional abstraction layers may include one or more classical computing devices (e.g., classical computers, classical processors, virtual machines, servers, etc.), quantum hardware or quantum software (e.g., quantum computing devices, quantum computers, quantum processors, quantum circuit simulation software, superconducting circuits, etc.), or combinations thereof, that may be used by the microservice generation system 102 or components thereof to perform one or more operations according to one or more embodiments of the invention described herein. For example, the microservice generation system 102 and / or its components may utilize one or more such classical or quantum computing or combination thereof resources to perform one or more classical or quantum or both mathematical functions, calculations or equations; computing or scripting or both; algorithms; models (e.g., artificial intelligence (AI) models, machine learning (ML) models, etc.); or other operations in accordance with one or more embodiments of the invention described herein.

[0025] Although this disclosure includes a detailed description of cloud computing, it should be understood that implementation of the teachings recited herein is not limited to a cloud computing environment, rather the inventive environment may be implemented in combination with any other type of computing environment now known or later developed.

[0026] Cloud computing is a service delivery model for on-demand network access with the convenience of accessing a shared pool of rapidly provisioned and open configurable computing resources (e.g., networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services) with minimal administrative effort or interaction with a service provider. The cloud model can include at least five characteristics, at least three service models, and at least four deployment models.

[0027] Its features are as follows:

[0028] On-Demand Self-Service: Cloud consumers are automatically provisioned with computing power - server time and network storage - on an as-needed basis without the need for human interaction with the service provider.

[0029] Pervasive Network Access: Capabilities are available over the network and accessed through standard mechanisms facilitating use by different thin- and thick-client platforms (eg, mobile phones, laptops, and PDAs).

[0030] Resource Sharing: Using a multi-tenant model, a provider's computing resources are shared to serve multiple consumers, with different physical and virtualized resources dynamically allocated and reallocated as needed. A sense of location independence exists, such that consumers generally have no control or knowledge of the exact location (e.g., country, state, or data center) of the resources provided, but can specify the location at a higher layer of abstraction.

[0031] Rapid Elasticity: Capabilities can be provisioned quickly and elastically, in some cases automatically, to quickly scale out and quickly release to quickly scale in. To the consumer, the capabilities available for provisioning often appear unlimited and can be purchased in any quantity at any time.

[0032] Metered Services: Cloud systems automatically control and optimize resource usage by leveraging metering capabilities at several levels of abstraction appropriate to the type of service (e.g., storage, processing, bandwidth, and active user accounts). Resource usage can be monitored, controlled, and reported to provide transparency to both providers and consumers of the services being used.

[0033] The service model is as follows:

[0034] Software as a Service (SaaS): The functionality offered to the consumer is the use of the provider's applications running on a cloud infrastructure. Applications are accessible from a variety of client devices through thin-client interfaces such as web browsers (e.g., web-based email). Consumers do not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, storage, or the functionality of individual applications, except for limited user-specific application configuration settings.

[0035] Platform as a Service (PaaS): The capability offered to a consumer is to deploy applications that the consumer has created or acquired, written using programming languages ​​and tools supported by the provider, onto a cloud infrastructure. The consumer does not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, or storage, but does control the deployed applications and, potentially, the configuration of the application hosting environment.

[0036] Infrastructure as a Service (IaaS): The facility provided to the consumer is the provision of processing, storage, networking, and other basic computing resources on which the consumer can deploy and run any software, which may include operating systems and applications. The consumer does not manage or control the underlying cloud infrastructure, but has control over the operating system, storage, deployed applications, and possibly limited control over select networking components (e.g., host firewalls).

[0037] The layout model is as follows:

[0038] Private Cloud: The cloud infrastructure operates solely for one organization. It can be managed by that organization or a third party and can exist on-premises or off-premises.

[0039] Community Cloud: The cloud infrastructure is shared by several organizations to support a specific community with common interests (e.g., mission, security requirements, policies, and compliance considerations). It can be managed by those organizations or by a third party and can exist on-premises or off-premises.

[0040] Public Cloud: Cloud infrastructure is made available to the public or large industry groups and is owned by organizations that sell cloud services.

[0041] Hybrid Cloud: A cloud infrastructure is a combination of two or more clouds (private, community, or public) that remain unique entities but are bound to each other by standardized or proprietary technologies that allow portability of data and applications (e.g., cloud bursting for load balancing between clouds).

[0042] Cloud computing environments are service-oriented with a focus on statelessness, loose coupling, modularity, and semantic interoperability. At the heart of cloud computing is the infrastructure, which contains multiple interconnected nodes.

[0043] The microservice generation system 102 may include a memory 104, a processor 106, a model component 108, a cluster component 110, or a bus 112, or any combination thereof.

[0044] It should be understood that the embodiments of the invention illustrated in the various figures disclosed herein are for illustrative purposes only, and thus the architecture of such embodiments is not limited to the systems, devices, or components, or combinations thereof, illustrated herein. For example, in some embodiments, system 100 or microservices generation system 102 or both may further include various computers or computing-based elements as described herein with reference to operating environment 800 and FIG. 8. In some embodiments, such computers or computing-based elements may be used in connection with implementing one or more systems, devices, components, or computer-implemented operations, or combinations thereof, as shown and described in connection with FIG. 1 or other figures disclosed herein.

[0045] The memory 104 may store one or more computer and / or machine readable, writable, or executable components or instructions, or combinations thereof, that when executed by the processor 106 (e.g., a classical processor, a quantum processor, etc.) facilitates the performance of operations defined by the executable component(s) or instruction(s) or combinations thereof. For example, the memory 104 may store computer and / or machine readable, writable, or executable components or instructions, or combinations thereof, that when executed by the processor 106 facilitates the performance of various functions described herein associated with the microservice generation system 102, the model component 108, the cluster component 110, or another component associated with the microservice generation system 102 (e.g., the collection component 202, the second model component 204, the refinement component 206, etc.), as described herein with or without reference to the various figures.

[0046] Memory 104 may include volatile memory (e.g., random access memory (RAM), static RAM (SRAM), dynamic RAM (DRAM), etc.) or non-volatile memory (e.g., read only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), etc.) that may utilize one or more memory architectures. Further examples of memory 104 are described below with reference to system memory 816 and FIG. 8. Any such embodiment of memory 104 may be utilized to implement any embodiment of the present invention.

[0047] Processor 106 may include one or more types of processors or electronic circuits, or combinations thereof (e.g., classical processors, quantum processors, etc.) capable of implementing one or more computer and / or machine readable, writeable, or executable components or instructions, or combinations thereof, that may be stored in memory 104. For example, processor 106 may be identified by components or instructions, or combinations thereof, that such computer and / or machine readable, writeable, or executable, including, but not limited to, logic, control, input / output (I / O), computation, or combinations thereof. In some embodiments, processor 106 may include one or more central processing units, multi-core processors, microprocessors, dual microprocessors, microcontrollers, systems on chips (SOCs), array processors, vector processors, quantum processors, or another type of processor, or combinations thereof. Further embodiments of the processor 106 are described below with reference to the processing unit 814 and FIGURE 8. Any such embodiment of the processor 106 may be utilized to implement any embodiment of the present invention.

[0048] The microservice generation system 102, memory 104, processor 106, model component 108, cluster component 110, or other components of the microservice generation system 102, or combinations thereof, are communicatively, electrically, operatively, or optically coupled to one another via a bus 112 to perform the functions of the system 100, the microservice generation system 102, or any components or combinations thereof coupled thereto, as described herein (e.g., collection component 202, second model component 204, refinement component 206, etc.). The bus 112 may include one or more of a memory bus, or memory controller, a peripheral bus, an external bus, a local bus, a quantum bus, or another type of bus or combinations thereof that may utilize various bus architectures. Further examples of the bus 112 are described below with reference to the system bus 818 and FIG. 8. Such examples of the bus 112 may be utilized to implement any embodiment of the present invention.

[0049] The microservices generation system 102 may include any type of component, machine, device, function, apparatus, or appliance that includes a processor or that is operable to or communicate with a wired or wireless network or both. All such embodiments are contemplated. For example, the microservices generation system 102 may include a server device, a computing device, a general purpose computer, a special purpose computer, a quantum computing device (e.g., a quantum computer), a tablet computing device, a handheld device, a server class computing machine, or a database, or a combination thereof, a laptop computer, a notebook computer, a desktop computer, a mobile phone, a smart phone, a home appliance or appliance, or both, an industrial or commercial device, or both, a digital assistant, a multimedia Internet enabled phone, a multimedia player, or another type of device, or a combination thereof.

[0050] The microservice generation system 102 can be coupled (e.g., communicatively, electrically, or optically) to one or more external systems, sources, or devices or combinations thereof (e.g., classical or quantum computing devices, communications devices, etc.) via a data cable (e.g., a High Definition Multimedia Interface (HDMI), Recommended Standard (RS) 232, Ethernet cable, etc.). In some embodiments, the microservice generation system 102 can be coupled (e.g., communicatively, electrically, or optically) to one or more external systems, sources, or devices or combinations thereof (e.g., classical or quantum computing devices, communications devices, etc.) via a network.

[0051] In some embodiments, such networks may include wired and wireless networks, including, but not limited to, a cellular network, a wide area network (WAN) (e.g., the Internet), or a local area network (LAN). For example, the microservices generation system 102 may generate and generate the microservices for a variety of mobile communication technologies, including, but not limited to, Wireless Fidelity (Wi-Fi), Global System for Mobile Communications (GSM), Universal Mobile Telecommunications System (UMTS), World Wide Interoperability for Microwave Access (WiMAX), Enhanced General Packet Radio Service (Enhanced GPRS), Third Generation Partnership Project (3GPP®), Long Term Evolution (LTE), Third Generation Partnership Evolution 2 (3GPP®2), Ultra Mobile Broadband (UMB), High Speed ​​Packet Access (HSPA), Zigbee™ and other 802.XX wireless technologies or legacy telecommunications technologies, BLUETOOTH®, Session Initiation Protocol (SIP), and the like. The device may communicate with one or more external systems, sources, or devices, or combinations thereof, such as computing devices (and vice versa), using virtually any wired or wireless technology desired, including SIP, ZIGBEE, RF4CE protocol, WirelessHART protocol, 6LoWPAN (IPv6 over Low Power Wireless Area Network), Z-Wave, ANT, Ultra Wideband (UWB) standard protocol, or other proprietary or non-proprietary communications protocol or combination thereof.In such embodiments, the microservice generation system 102 may thus include hardware (e.g., a central processing unit (CPU), a transceiver, a decoder, quantum hardware, a quantum processor, etc.), software (e.g., a set of threads, a set of processes, running software, quantum pulse schedules, quantum circuits, quantum gates, etc.), or a combination of hardware and software that facilitates communication of information between the microservice generation system 102 and an external system, source, or device or combination thereof (e.g., a computing device, a communications device, etc.).

[0052] The microservice generation system 102 may include one or more computer or machine writeable, readable, or executable, or any combination thereof, components or instructions that, when executed by the processor 106 (e.g., a classical processor, a quantum processor, etc.), facilitate the performance of operations defined by such component(s) or instruction(s). Additionally, in various embodiments, as described herein with or without reference to the various figures, any component associated with the microservice generation system 102 may include one or more computer or machine readable, writeable, or executable, or any combination thereof, components or instructions that, when executed by the processor 106, facilitate the performance of operations defined by such component(s) or instruction(s). For example, the model component 108, the cluster component 110, or any other component associated with the microservice generation system 102 may include component(s) or instruction(s) or combination(s) that such computer or machine or both may read, write, or execute, or any combination thereof, as described herein (e.g., communicatively, electronically, operationally, or optically coupled or utilized, or any combination thereof, by the microservice generation system 102). As a result, according to numerous embodiments, the microservice generation system 102 or any component or both associated therewith may use the processor 106 to execute the component(s) or instruction(s) that such computer or machine or both may read, write, or execute, or any combination thereof, as described herein, to facilitate performance of one or more operations described herein with reference to the microservice generation system 102 or any such component or combination thereof associated therewith.

[0053] The microservice generation system 102 may facilitate (e.g., via the processor 106) the performance of operations performed by or associated with the model component 108 or the cluster component 110, or another component associated with the microservice generation system 102, or a combination thereof (e.g., the collection component 202, the second model component 204, the refinement component 206, etc.), as described herein. For example, as described below, the microservice generation system 102 may facilitate, via the processor 106 (e.g., a classical processor, a quantum processor, etc.): training a model to learn cluster assignments of classes in a monolithic application based on runtime traces of executed test cases; or utilizing the model to generate clusters of classes based on the cluster assignments to identify microservices for one or more monolithic applications, or both. As referred to herein, a cluster may be defined as a group of classes that can be grouped together by the microservices generation system 102 or one or more components thereof, or combinations thereof (e.g., model component 108, cluster component 110, collection component 202, second model component 204, refinement component 206, etc.) based on one or more defined purposes (e.g., business context, call volume, etc.) as described herein. More specifically, in the domain applied to microservices refactoring of monoliths (also referred to as application modernization), as referred to herein, a cluster may be defined as a group of classes that can be composed into microservices.

[0054] In the above embodiment, as described in more detail below, the microservice generation system 102 may further include, via the processor 106 (e.g., a classical processor, a quantum processor, etc.): refining one or more microservices based on at least one of the data dependencies of the monolithic application or the static call graph of the monolithic application; generating one or more causal graphs based on the runtime traces of the executed test cases to capture at least one of the first order time dependencies or higher order time dependencies of the monolithic application or at least one of the cluster assignments of classes in the monolithic application; or training a model to learn at least one of the cluster assignments or graph embeddings of classes in the monolithic application using the causal sequences of the one or more causal graphs generated based on the runtime traces of the executed test cases, or both. In the above embodiment, the executed test cases may include business functionality test cases that provide a business functionality of the monolithic application within the runtime traces.

[0055] In another embodiment, as described in more detail below, the microservice generation system 102 may further include, via the processor 106 (e.g., a classical processor, a quantum processor, etc.): collecting runtime traces of test cases executed on the monolithic application; training a model based on the runtime traces to learn cluster assignments of classes in the monolithic application; or generating clusters of classes based on the cluster assignments to identify one or more microservices of the monolithic application, or both. In this embodiment, as described below, the microservice generation system 102 may further include, via the processor 106 (e.g., a classical processor, a quantum processor, etc.), refining one or more microservices based on at least one of the data dependencies or static call graphs of the monolithic application; generating one or more causal graphs based on the runtime trace to capture at least one of first order time dependencies or higher order time dependencies of the monolithic application or at least one of the cluster assignments of classes in the monolithic application; or training a model to learn at least one of the graph embeddings of the classes or the cluster assignments in the monolithic application using causal sequences of the one or more causal graphs generated based on the runtime trace, or both. In this embodiment, the test cases executed may include business functionality test cases that provide a business functionality of the monolithic application within the runtime trace.

[0056] The model component 108 can learn cluster assignments of classes in a monolithic application based on executed test cases. For example, the model component 108 can include an artificial intelligence (AI) or machine learning (ML) model (e.g., a neural network) that can be trained (e.g., via the microservices generation system 102) to learn cluster assignments of classes in a monolithic application (e.g., a monolith enterprise application) based on runtime traces that can be generated utilizing the monolithic application for execution of such test cases (e.g., via the processor 106). In some embodiments, the model component 108 can include a model 400, described below and illustrated in FIG. 4, where the model 400 can include a neural network that can be trained (e.g., via the microservices generation system 102, described below) to learn cluster assignments of classes in a monolithic application (e.g., a monolith enterprise application) based on runtime traces that can be generated utilizing the monolithic application for execution of such test cases (e.g., via the processor 106).

[0057] In an embodiment, the executed test cases described above may include business functionality test cases that may be executed using the monolithic application (e.g., running on the monolithic application via the processor 106). In this embodiment, such business functionality test cases may provide the business functionality of the monolithic application in a runtime trace. For example, such business functionality test cases may provide the microservice generation system 102 and / or the model component 108 with the order and frequency of how the classes and function calls of the monolithic application interact, and may further provide the microservice generation system 102 and / or the model component 108 with associating business context with the respective traces to refine the functional groupings (e.g., via the microservice generation system 102, the model component 108, and / or the cluster component 110, as described below).

[0058] The model component 108 may learn cluster assignments of classes in the monolithic application or graph embeddings of such classes in the monolithic application, or both, using causal sequences of one or more causal graphs that may be generated based on runtime traces, which may be generated by executing test cases on the monolithic application as described above. In an embodiment, the model component 108 may learn the above-mentioned cluster assignments and graph embeddings simultaneously (e.g., by the second model component 204 as described below with reference to FIG. 2) using causal sequences of one or more causal graphs that may be generated based on runtime traces, which ... and both. In this embodiment, the generation of such one or more above-mentioned causal graphs (e.g., by the second model component 204) provides the microservice generation system 102 or the model component 108, or both, with: first-order time dependencies or higher-order time dependencies of the monolithic application, or both; or cluster assignments of classes in the monolithic application, or a combination thereof.

[0059] To facilitate such learning by the model component 108 described above, the microservice generation system 102 can train the model component 108. For example, the model component 108 can include an artificial intelligence (AI) or machine learning (ML) model, such as a neural network (e.g., model 400), that can be trained by the microservice generation system 102 to learn cluster assignments or graph embeddings, or both, using the causal sequences of one or more causal graphs described above. For example, the microservice generation system 102 can train the model component 108 to learn cluster assignments or graph embeddings, or both, by implementing a training procedure described below.

[0060] To illustrate the above-described training procedures that the microservices generation system 102 may implement to train the model component 108 to learn the above-described cluster assignments or graph embeddings, or both, the monolithic application described above may include an example trading application including, for example, a Java 2 Platform Enterprise Edition (J2EE) application that may be used for trading security assets in one or more financial markets. In this embodiment, the example trading application may include a J2EE application for online stock trading that allows users to log in, view their portfolios, look up stock prices, or buy and sell stock shares, or any combination thereof. In this embodiment, the runtime traces generated by test cases (e.g., business functional test cases) running on the example trading application include multi-threaded runtime traces that may represent a three-tire architecture of a presentation layer, business logic, and persistence layer. In this embodiment, such runtime traces may be generated by executing (e.g., by the processor 106) on the example trading application test cases (e.g., business function test cases), including, but not limited to, init, login, log-off, trade account update profile, market summary glossary, trade quote buy, trade portfolio sell, or another test case or combination thereof. In this embodiment, the classes and their calls to other classes may involve multiple business contexts. In this embodiment, runtime traces that may be generated by executing such test cases defined above on the example trading application may include the following runtime traces:

[0061] 1567027540073,init,Root calls MarketSummarySingleton

[0062] 1567027540074,init,MarketSummarySingleton calls Log

[0063] 1567027540075,init,Log calls TradeConfig

[0064] 1567027540076, init, TradeConfig returns to Log

[0065] 1567027540077,init,Log calls TradeConfig

[0066] 1567027540078, init, TradeConfig returns to Log

[0067] 1567027540079, init, Log returns to MarketSummarySingleton

[0068] ......

[0069] 1567027743085,trade-quotes-buy,Root calls OrdersAlertFilter

[0070] 1567027743086,trade-quotes-buy,OrdersAlertFilter calls TradeConfig

[0071] 1567027743087,trade-quotes-buy,TradeConfig returns OrdersAlertFilter

[0072] Root - MarketSummarySingleton - Log - TradeConfig - (TradeConfig-Log) -- log - MarketSummarySingleton init

[0073] Root - OrdersAlertFilter - TradeConfig - (TradeConfig-OrdersAlertFilter) -- OrdersAlertFilter trade-quotes-buy

[0074] In this embodiment, where the monolithic application includes the example trading application, the microservice generation system 102 can generate one or more cause graphs including causal sequences based on the runtime traces defined above. In this embodiment, the microservice generation system 102 generates such one or more cause graphs to capture first order time dependencies or higher order time dependencies or both of the monolithic application or classes in the monolithic application. In this embodiment, to facilitate the generation of such one or more cause graphs, the microservice generation system 102 can utilize a second model component (e.g., second model component 204 described below with reference to FIG. 2 ) that can include a neural network, such as a higher order temporal neural network, for generating such cause graph(s) as described above. In this embodiment, the microservice generation system 102 can use such a second model component (e.g., the second model component 204 described below with reference to FIG. 2) to capture the temporal relationships of the paths (e.g., via the generation of a causal graph including the causal sequences described above) and to extrapolate highly related invocation sequences.

[0075] In this embodiment, where the monolithic application includes the example trading application, the microservice generation system 102 may train the model component 108 using the causal sequences of one or more causal graphs described above as input to learn the cluster assignments or graph embeddings or both described above (also referred to herein as runtime causal sequences or runtime sequences or both), where the output is a node embedding (e.g., a mapping f:V → R d ) and cluster assignment. In this embodiment, the microservice generation system 102 can train the model component 108 to directly sample nearby nodes from the runtime causal sequence. In this embodiment, for a given runtime sequence S, a collection of windows that contains node v is denoted by N s In this embodiment, the microservice generation system 102 can train the model component 108 to generate one or more positive example pairs from a causal sequence by implementing the following example routine:

[0076] For the given runtime sequence “Root, MarketSummarySingleton, Log, TradeConfig, TradeConfig”, return Log and an observation window of size 3.

[0077] ……

[0078] The node "MarketSummarySingleton" has a neighborhood window Ns(v=MarketSummarySingleton).

[0079] [Root, MarketSummarySingleton, Log]

[0080] [MarketSummarySingleton, Log, TradeConfig]

[0081] Extract positive sample pairs:

[0082] (MarketSummarySingleton, Root)

[0083] (MarketSummarySingleton, Log)

[0084] (MarketSummarySingleton, TradeConfig)

[0085] In this example embodiment, the monolithic application includes an example trading application, and the model component 108 can include a neural network, such as model 400 shown in FIG. 4. In this embodiment, the microservice generation system 102 can cause the model component 108 (e.g., model 400) to learn the cluster assignments or graph embeddings or both described above by training the model component 108 on the following task: Given a particular class A in a runtime sequence, the microservice generation system 102 trains the model component 108 to predict the probability for each class that is a "neighbor" class of A in the runtime sequence. In this embodiment, if two Java classes have very similar "contexts," which can mean that these two classes tend to co-occur in the same context window under the same business context, the microservice generation system 102 can train the model component 108 to output similar embeddings for these two classes. In this embodiment using sequence-based embedding, a sequence of neighboring nodes can be sampled from the causal graph(s) using a method such as a random walk (e.g., by the microservice generation system 102 or the model component 108 or both), and the objective can be to minimize the negative log-likelihood of observing the node's neighbors.

[0086] In this example embodiment, the monolithic application includes an example trading application, and the microservice generation system 102 can train the model component 108 to achieve the minimization of the negative log-likelihood of observing the neighborhood of a node described above based on the node embedding conditions according to equation (1) defined below:

[0087]

number

[0088] where f(v) denotes the embedding for node v, P denotes the probability function, and N s (i) denotes the collection of neighboring nodes around node v.

[0089] In this example embodiment, the monolithic application includes an example trading application, and according to the assumption of conditional independence and symmetry in future space, equation (1) defined above can be formulated by the microservice generation system 102 or the model component 108, or both, as equation (2) defined below.

[0090]

number

[0091] Here, L h denotes the embedding optimization function, u denotes node u, f(u) denotes the embedding of node u, and f(n i ) at node n i This means embedding for

[0092] In this example embodiment, the monolithic application includes an example trading application, and the microservice generation system 102 can train the model component 108 to learn cluster assignments or graph embeddings or both simultaneously. For example, to facilitate such concurrent learning, the microservice generation system 102 can train the model component 108 by extending the objective function (e.g., Equation (2)) to include a k-means cost function of Equation (3) defined below:

[0093]

number

[0094] Here, L c denotes the overall optimization function for both embedding and clustering, γ denotes a hyper-parameter for determining the weight coefficient of the cluster cost, and u c denotes the cluster mean of the cth cluster. Note that these are trainable parameters.

[0095] In some embodiments, the microservice generation system 102 can include or utilize one or more artificial intelligence (AI) models or one or more machine learning (ML) models or both to train the model component 108 to learn cluster assignments or graph embeddings or both as described above using the causal sequences of the one or more causal graphs described above. For example, the microservice generation system 102 can include or utilize one or more AI or ML models or both to train the model component 108 to learn cluster assignments or graph embeddings or both as described above using the causal sequences of the one or more causal graphs described above and using one or more unsupervised learning models (e.g., unsupervised clustering methods such as, illustratively, the training procedures described above).

[0096] In some embodiments, the microservice generation system 102 can train the model component 108 to learn the cluster assignments and / or graph embeddings described above using causal sequences of one or more causal graphs described above based on classification, correlation estimation, or representations related to principles of artificial intelligence, or combinations thereof. For example, the microservice generation system 102 can use an automated classification system or process or both to train the model component 108 to learn the cluster assignments and / or graph embeddings described above using causal sequences of one or more causal graphs described above. In one embodiment, the microservice generation system 102 can use a probabilistic or statistical-based analysis (e.g., factoring into the analysis utility and cost) to train the model component 108 to learn the cluster assignments and / or graph embeddings described above using causal sequences of one or more causal graphs described above.

[0097] In some embodiments, the microservice generation system 102 may use any suitable machine learning, statistical, or probability based, or combination thereof, techniques to train the model component 108 using the causal sequences of one or more causal graphs described above to learn the cluster assignments or graph embeddings or both described above. For example, the microservice generation system 102 may use expert systems, fuzzy logic, support vector machines (SVMs), hidden Markov models (HMMs), greedy search algorithms, rule-based systems, Bayesian models (e.g., Bayesian networks), neural networks, other non-linear training techniques, data fusion, utility-based analysis systems, systems using Bayesian models, or other models, or combinations thereof. In some embodiments, the microservice generation system 102 may perform a set of machine learning calculations associated with the training model component 108 to train the causal sequences of one or more causal graphs to learn the cluster assignments or graph embeddings or both described above.For example, the microservices generation system 102 may run a set of clustering machine learning calculations, a set of logistic regression machine learning calculations, a set of decision tree machine learning calculations, a set of random forest machine learning calculations, a set of regression tree machine learning calculations, a set of least squares machine learning calculations, a set of instance-based machine learning calculations, a set of regression machine learning calculations, a set of support vector regression calculations, a set of k-means machine learning calculations, a set of spectral clustering machine learning calculations, a set of rule learning machine learning calculations, a set of Bayesian machine learning calculations, a set of deep Boltzmann machine learning calculations, a set of deep belief network calculations, or a set of different machine learning calculations, or a combination thereof, to train the model component 108 to learn the cluster assignments or graph embeddings, or both, described above, using causal sequences of one or more causal graphs described above.

[0098] The cluster component 110 can generate clusters of classes in the monolithic application based on cluster assignments in the monolithic application that identify one or more microservices of the monolithic application using the model component 108. For example, based on the microservice generation system 102 training the model component 108 to learn cluster assignments and / or graph embeddings for the monolithic application using causal sequences of one or more causal graphs described above, the cluster component 110 utilizes a trained version of the model component 108 to generate clusters of classes in the monolithic application based on such cluster assignments and / or graph embeddings learned by the model component 108. In this embodiment, the clusters of classes (via the model component 108) that may be generated by the cluster component 110 described above may identify one or more microservices of a monolithic application (one or more potential microservice candidates of the monolithic application) that may then be identified by the cluster component 110 and / or further refined by the refinement component 206, as described below with reference to FIG. 2.

[0099] 2 illustrates a block diagram of an example non-limiting system 200 that can facilitate generating microservices from a monolithic application based on runtime traces in accordance with one or more embodiments described herein. The system 200 can include a microservice generation system 102, which can further include a collection component 202, a second model component 204, or a refinement component 206, or a combination thereof. A description of each similar element or process or combination thereof utilized in each embodiment may be omitted for the purpose of brevity.

[0100] The collection component 202 can collect runtime traces of test cases executed for the monolithic application. For example, the collection component 202 can collect runtime traces that can be generated by execution (e.g., via the processor 106) of test cases using the monolithic application, where such test cases can include the business functionality test cases described above with reference to FIG.

[0101] To facilitate collection of such runtime traces as described above, the collection component 202 may utilize artificial intelligence (AI) based machine learning (ML) and natural language processing (NLP) or named entity recognition (NER) or combinations thereof, including but not limited to shallow or deep neural network models, support vector machines (SVM), decision tree classifiers, or any supervised or unsupervised machine learning models, that may facilitate extraction of runtime traces generated by executing such test cases as described above using the monolithic application. For example, the collection component 202 may utilize a monitoring application that may generate runtime logs from the instrumented source code of the monolithic application. In another embodiment, the collection component 202 may use a Python-based tool to extract information, such as class names, attributes, method names, method arguments, return types, or other information, or combinations thereof, from the source code of the monolithic application, where such Python-based tool may further inject code into the monolithic application for runtime trace generation. In another embodiment, the collection component 202 can use a Java front-end tool capable of generating traces based on the business context. In another embodiment, the collection component 202 can use an extraction application capable of extracting inheritance relationships, data dependencies, attributes, method arguments, return types, or other relationships or combinations thereof.

[0102] The second model component 204 can generate one or more causal graphs based on runtime traces of test cases executed on the monolithic application to capture first order or higher order temporal dependencies of the monolithic application or cluster assignments of classes in the monolithic application, or both. For example, the second model component 204 can generate one or more causal graphs as described above with reference to FIG. 1 based on runtime traces generated by execution of business functional test cases on the monolithic application to capture first order or higher order temporal dependencies of the monolithic application or cluster assignments of classes in the monolithic application, or both.

[0103] The second model component 204 may include a neural network. In an embodiment, the second model component 204 may include a higher order temporal neural network capable of generating one or more causal graphs including causal sequences based on the runtime traces described above with reference to FIG. 1, capturing first order temporal dependencies or higher order temporal dependencies or both as described above. For example, the second model component 204 may include a higher order temporal neural network capable of generating one or more causal graphs including causal sequences based on the runtime traces described above with reference to FIG. 1, capturing temporal relationships of paths and extrapolating highly related invocation sequences. In an embodiment, such causal graph(s) or causal sequences that may be generated by the second model component 204 may be used by the microservice generation system 102 to train the model component 108 to learn cluster assignments or graph embeddings or both for the monolithic application as described above with reference to FIG. 1.

[0104] The refinement component 206 can refine one or more microservices of the monolithic application based on (e.g., using) the data dependencies of the monolithic application, or the static call graph of the monolithic application, or both. For example, a cluster of classes (e.g., through use of the model component 108) that may be generated as described above by the cluster component 110 can identify one or more microservices of the monolithic application (one or more potential microservice candidates for the monolithic application), which can be further refined by the refinement component 206 based on (e.g., using) the data dependencies of the monolithic application, or the static call graph of the monolithic application, or both, as described below.

[0105] In the example embodiment of the trading application described above with reference to FIG. 1, the refinement component 206 can augment the cost function (e.g., Equation (3)) to add an additional constraint term to facilitate refinement of such one or more microservices of the monolithic application based on (e.g., using) the data dependencies of the monolithic application or the static call graph of the monolithic application or both. For example, in the example embodiment of the trading application described above with reference to FIG. 1, the refinement component 206 can augment the cost function (e.g., Equation (3)) to add an additional constraint term to obtain Equation (4) defined below: In an example embodiment of the trading application described above with reference to FIG. 1, the refinement component 206 may utilize equation (4) defined below to refine one or more microservices of the monolithic application based on (e.g., using) the data dependencies of the monolithic application or the static call graph of the monolithic application, or both, where such data dependencies or static call graph may be collected by the collection component 202 as described above (e.g., collected from runtime traces generated by executing business functional test cases using the monolithic application).

[0106]

number

[0107] Here, ω (u,v) denotes the regulation weight, and λ i denotes a regulatory coefficient (e.g., determining the severity of a penalty).

[0108] In the above example, c2 is a cluster where u and v belong to different clusters but have a runtime invocation dependency, and ω 2(u,v)Calculate the normalized call frequency. In the above example, if two classes have frequent function calls, then their representations should be close (e.g., call volume between clusters).

[0109] 3 illustrates a flow diagram of an example non-limiting computer-implemented method 300 that can facilitate generating microservices from a monolithic application according to one or more embodiments described herein. Descriptions of each similar element or process or combination thereof utilized in each embodiment are omitted for purposes of brevity.

[0110] At 302, the computer-implemented method 300 can include collecting input data (e.g., via the microservice generation system 102 or the collection component 202, or both). For example, as described above with reference to FIG. 2, the collection component 202 can collect runtime traces, which can be generated by executing (e.g., via the processor 106) test cases (e.g., business functionality test cases) using the monolithic application.

[0111] In an embodiment, as shown in Fig. 3, at 302, the collection component 202 can utilize a monitoring application that can generate runtime logs from source code implemented by the monolithic application. In this embodiment, as shown in Fig. 3, at 302, such a monitoring application can generate runtime logs formatted as log files or text files or both.

[0112] In another embodiment, as shown in FIG. 3, at 302, the collection component 202 can utilize a runtime context generator, such as a Java front-end tool, that can generate a runtime context. In this embodiment, as shown in FIG. 3, at 302, such a runtime context generator can generate a runtime context that includes context labels (e.g., business context labels) formatted as a Java Script Object Notation (JSON) file or a Comma Separated Value (CSV) file. In this embodiment, an entity (e.g., a human, a client, a user, a computing device, a software application, an agent, a machine learning (ML) model, an artificial intelligence (AI) model, etc.) that implements the microservice generation system 102 can define such context labels (e.g., business context labels) using interface components (not shown) of the microservice generation system 102 (e.g., application programming interfaces (APIs), representational state transition APIs, graphical user interfaces (GUIs), etc.).

[0113] In another embodiment, as shown in FIGURE 3 at 302, the collection component 202 can utilize a data dependency generator, such as a Python-based tool, to extract information from the source code of the monolithic application that can be used to generate a data dependency graph, where such information can include class names, attributes, method names, method arguments, return types, or other information, or combinations thereof. In this embodiment, as shown in FIGURE 3 at 302, such a data dependency generator can generate a data dependency graph that includes a symbol table (denoted as symTable in FIGURE 3) or a reference table (denoted as refTable in FIGURE 3), or both, which can be formatted as a JSON file.

[0114] In another embodiment, as shown in FIG. 3, at 302, the collection component 202 can generate a static call graph using a static call graph generator, such as an extractor application that can extract inheritance relationships, data dependencies, attributes, method arguments, return types, or other relationships, or combinations thereof. In this embodiment, as shown in FIG. 3, at 302, such a static call graph generator can generate a static call graph formatted as JSON. In this embodiment, as shown in FIG. 3, at 302, the microservice generation system 102 or the collection component 202, or both, can filter out non-application classes from the static call graph, where such filtered static call graph can be used to refine clusters of classes or provided to a user interface (UI), or both, as described below.

[0115] At 304, the computer-implemented method 300 may include generating a runtime trace (e.g., by the microservice generation system 102 or the second model component 204, or both). For example, as shown in FIG. 3, at 304, based on the collection of runtime logs or generation of runtime contexts from implementation sources or both (e.g., business context or business context labels, or both) at 302 described above, the microservice generation system 102 or the second model component 204, or both, may generate flows (e.g., causal sequences, data flows, etc.) and add text labels to each trace generated by the execution of the test cases (e.g., business functional test cases) described above using the monolithic application, thereby obtaining a runtime trace that may be formatted as a JSON file(s).

[0116] At 306, the computer-implemented method 300 can include clustering the classes of the monolithic application (e.g., the microservice generation system 102, the model component 108, the cluster component 110, or the second model component 204, or a combination thereof) to generate clusterings A, B, or C, or a combination thereof, as illustrated in Figure 3. For example, to facilitate such clustering of the classes at 306, the computer-implemented method 300 can include assigning clusters to the classes of the monolithic application (e.g., the microservice generation system 102, the model component 108, the cluster component 110, or the second model component 204, or a combination thereof) to generate clusterings A, B, or C, or a combination thereof, as illustrated in Figure 3.For example, as shown in FIG. 3 , at 306, the computer-implemented method 300 may include: a) generating and / or applying a causal graph (e.g., via the microservice generation system 102 or the second model component 204 or both) to obtain inter-dependencies to obtain a clustering A; b) generating and / or applying a causal graph (e.g., via the microservice generation system 102, the model component 108, the cluster component 110, or the second model component 204 or a combination thereof) to train the model component 108 to learn cluster assignments and / or graph embeddings for the monolithic application (see FIGS. 1 and 2 ). or c) applying the runtime traces generated in 304 as described above (e.g., by the microservice generation system 102, the model component 108 or the cluster component 110, or a combination thereof) to train the model component 108 and learn cluster assignments or graph embeddings or both for the monolithic application (as described above with reference to Figures 1 and 2) to obtain partitions for the respective classes using the causal graph, thereby obtaining clustering C, or a combination of these.

[0117] At 308, the computer-implemented method 300 may include refining the clusterings A, B, or C, or combinations thereof, based on the data dependency graph generated at 302 described above and using input from an entity (e.g., a human, a client, a user, a computing device, a software application, an agent, a machine learning (ML) model, an artificial intelligence (AI) model, etc.) as illustrated in FIG. 3 (e.g., the microservice generation system 102 or the refinement component 206, or a combination thereof). For example, at 308 as illustrated in FIG. 3, the refinement component 206 or the entities described above or a combination thereof may add classes (e.g., to A, B, or C, or combinations thereof) that are not present in the runtime trace, where such classes have data dependencies (e.g., data dependencies of one or more classes in the clusterings A, B, or C, or combinations thereof, determined using the data dependency graph). In this embodiment, the refinement component 206 or any of the entities described above or any combination thereof may further merge clusters (e.g., A, B, or C, or combinations thereof) with cross-cluster data dependencies (e.g., cross-cluster data dependencies between classes of clustering A, B, or C, or combinations thereof) as shown in Fig. 3 at 308. In this embodiment, such refinement operations as described above may be implemented to generate natural seams as shown in Fig. 3 at 308.

[0118] At 310, the computer-implemented method 300 may include refining (by the microservice generation system 102 or the refinement component 206, or both) the clusterings A, B, or C, or combinations thereof, based on the static call graph (e.g., filtered static call graph) generated at 302 described above and using input from an entity (e.g., a human, a client, a user, a computing device, a software application, an agent, a machine learning (ML) model, an artificial intelligence (AI) model, etc.). For example, at 310 as shown in FIG. 3, the refinement component 206 or the entities defined above, or combinations thereof, may add classes (e.g., to A, B, or C, or combinations thereof) that are not present in the runtime trace, where such classes have static call dependencies (e.g., static call dependencies with one or more classes in the clusterings A, B, or C, or combinations thereof, determined using the static call graph). In this embodiment, at 310 as shown in Figure 3, the refinement component 206 or the entities defined above or a combination thereof may further add (e.g., to A, B, or C, or a combination thereof) clusters that have no call dependencies on the classes (e.g., there are no static call dependencies within one or more classes within clustering A, B, or C, or a combination thereof, determined using the static call graph). In this example, at 310 as shown in Figure 3, such refinement operations described above may be implemented to generate business logic.

[0119] In an embodiment, as shown in Figure 3, the data dependency graph or the static call graph (e.g., a filtered static call graph) generated in 302 described above, or a combination thereof, can be provided to a user interface (UI) as a JSON file. In an embodiment, as shown in Figure 3, the runtime trace generated in 304 described above can be provided to a user interface (UI) in the form of a runtime graph that can be formatted as a JSON file. In an embodiment, as shown in Figure 3, the natural seams or business logic or both generated in 308 and 310, respectively, as described above, can be provided to a user interface (UI) as a JSON file.

[0120] 4 illustrates a diagram of an example non-limiting model 400 that can facilitate the generation of microservices from a monolithic application based on runtime traces, in accordance with one or more embodiments described herein. Descriptions of each of the similar elements or processes or combinations thereof utilized in each embodiment are omitted for purposes of brevity.

[0121] In some embodiments, the model component 108 or the second model component 204, or a combination thereof, can include a model 400. For example, as described above in FIG. 1, the model component 108 includes a model 400, which can include a neural network that can be trained (e.g., via the microservices generation system 102 described above) to learn cluster assignments or graph embeddings, or both, as described above, using causal sequences of one or more causal graphs as described above.

[0122] As shown in FIG. 4, the model 400 may include an input layer 402, an embedding layer 404, or an output layer 406, or a combination thereof. In the embodiment of the example trading application described above with reference to FIG. 1, the input layer 402 may provide the embedding layer 404 with Java classes of the monolithic application in the form of input vectors as shown in FIG. 4 (depicted as “MarketSummarySingleton” in FIG. 4). The embedding layer 404 may generate one or more embeddings of the input Java classes, where such one or more embeddings may include one or more vector representations of the input Java classes. Based on such vector representation(s) of the input Java classes, the output layer 406 may include a softmax classifier as shown in FIG. 4 and may predict whether another class of the monolithic application is within a predefined window (e.g., window size 3 as shown in the example trading application described above with reference to FIG. 1). For example, the output layer 406 can predict whether a pair of Java classes in a monolithic application belong within the same window (denoted as "neighborhood" in FIG. 4).For example, in an example trading application embodiment as described above with reference to FIG. 1 and shown in FIG. 4, based on the embedding layer 404 generating a vector representation of an input Java class, depicted in FIG. 4 as “MarketSummarySingleton,” the output layer 406 may predict: a) the probability that the class “Log” is in the neighborhood (e.g., within window size 3 with respect to the input Java class “MarketSummarySingleton,”); b) the probability that the class “TradeConfig” is in the neighborhood (e.g., within window size 3 with respect to the input Java class “MarketSummarySingleton,”); c) the probability that the class “QuoteDataBeam” is in the neighborhood (e.g., within window size 3 with respect to the input Java class “MarketSummarySingleton,”); or d) the probability that the class “TradeSLSBBeam” is in the neighborhood (e.g., within window size 3 with respect to the input Java class “MarketSummarySingleton”), or a combination thereof.

[0123] The microservices production system 102 can be associated with a variety of technologies, for example, the microservices production system 102 can be associated with application modernization technologies, monolithic application technologies, monolithic enterprise application technologies, application programming technologies, cloud computing technologies, machine learning technologies, artificial intelligence technologies, or other technologies or combinations of such technologies.

[0124] The microservice generation system 102 can provide technical improvements to systems, devices, components, operational steps, or process steps, or combinations thereof, associated with the various technologies identified above. For example, the microservice generation system 102 can train a model to learn cluster assignments or graph embeddings of classes, or both, in a monolithic application based on runtime traces of business functional test cases that can be executed using the monolithic application, or can further use the model to generate clusters of classes based on the cluster assignments or graph embeddings to identify one or more microservices of the monolithic application, or combinations thereof. Execution of such business functional test cases using the monolithic application can result in runtime traces corresponding to each such business functional test case. The microservice generation system 102 can use such runtime traces corresponding to each business functional test case to generate a cause graph including cause sequences also corresponding to each such business functional test case. Such cause graphs or cause sequences or combinations thereof corresponding to each business functionality test case provide the microservice generation system 102 with first order and / or higher order temporal dependencies of the monolithic application or clusters of classes in the monolithic application, where such dependencies correspond to each business functionality test case. These first order and / or higher order temporal dependencies provide the microservice generation system 102 with various business functions of the monolithic application, such as, for example, the order and frequency of how the classes and function calls of the monolithic application interact.The first-order temporal dependencies or higher-order temporal dependencies or both may further enable the microservice generation system 102 to associate business context with each trace to provide improved functional grouping (e.g., functional clustering) of classes in the monolithic application. Such improved functional grouping of classes in the monolithic application may enable the microservice generation system 102 to more accurately identify one or more microservices of the monolithic application, thereby facilitating improved application modernization of the monolithic application by the microservice generation system 102.

[0125] The microservices generation system 102 may provide technical improvements to a processing unit (e.g., processor 106) associated with a classical or quantum computing device, or both, associated with the microservices generation system 102. For example, improving the functional grouping of classes in a monolithic application (e.g., functional clustering), as described above, may enable the microservices generation system 102 to more accurately identify one or more microservices of the monolithic application, and may enable the microservices generation system 102 to reduce the workload of a processor (e.g., processor 106) used to perform application modernization of the monolithic application (e.g., by reducing the number of processing cycles that such processor performs to complete an application modernization process). Reducing such workload of such a processor (e.g., processor 106) may improve the processing performance or processing efficiency of such processor, or both, or may further reduce the computational cost of such processor, or both.

[0126] A practical use of the microservices generation system 102 is that it can be implemented to perform an improved application modernization process for monolithic applications. For example, a practical use of the microservices generation system 102 is that it can be implemented by a monolithic application owner (e.g., a monolithic enterprise application) to enable the quick and accurate identification of microservices for the monolithic application, thereby improving the application modernization process for the monolithic application.

[0127] It should be appreciated that the microservices generation system 102 provides a new approach driven by relatively new application modernization techniques that currently involve making assumptions about certain designs or programming models associated with monolithic applications, or involving performing an application modernization process for monolithic applications with intentional manual input from a human, or both. For example, the microservices generation system 102 provides a new automated approach to performing application modernization of monolithic applications without intentional input from a human about: defining such assumptions about certain designs or programming models associated with monolithic applications; identifying classes or clusters of classes or both of the monolithic application that may constitute microservice candidates for the monolithic application; or refining such potential microservice candidates to identify microservices of the monolithic application that may be included or implemented as standalone applications for the monolithic application, or both; or a combination of these.

[0128] The microservices generation system 102 may use hardware or software to solve problems that are highly technical in nature, not abstract, and not possible to perform as a set of mental activities by a human. In some embodiments, one or more processes described herein are executed by one or more specialized computers (e.g., specialized processing units, specialized classical computers, specialized quantum computers, etc.) to perform defined tasks associated with the various technologies identified above. The microservices generation system 102 or components thereof or both may be utilized to solve novel problems that arise through the use of the technological advances described above, quantum computing systems, cloud computing systems, computer architectures, or other technologies, or combinations thereof.

[0129] It will be appreciated that the various operations, or components thereof, or both that can be performed by the microservice generation system 102 described herein are operations that are far beyond the capabilities of the human mind, such that the microservice generation system 102 can utilize various electrical components, mechanical components, and circuitry that cannot be replicated in or performed by the human mind. For example, the amount of data, the rate at which such data is processed, or the types of data processed by the microservice generation system 102 over a period of time may be greater, faster, or different than the amount, rate, or type of data that can be processed by the human mind over the same time interval.

[0130] According to some embodiments, the microservice generation system 102 is also fully operable to perform one or more other functions (e.g., fully powered, fully running, etc.) while performing various operations described herein. It should be appreciated that such synchronous multi-operational execution is beyond the capabilities of the human mind. The microservice generation system 102 may also include information that is not manually obtainable by an entity such as a human user. For example, the type, amount, or variety of information included in the microservice generation system 102, the model component 108, the cluster component 110, the collection component 202, the second model component 204, the refinement component 206, or the model 400, or combinations thereof, is more complex than information that may be manually obtained by a human user.

[0131] 5 illustrates a flow diagram of an example non-limiting computer-implemented method 500 that can facilitate generating microservices from a monolithic application based on runtime tracing in accordance with one or more embodiments described herein. Descriptions of each similar element or process or combination thereof utilized in each embodiment are omitted for purposes of brevity.

[0132] At 502, the computer-implemented method 500 may include training a model (e.g., model component 108, model 400, etc.) by a system (e.g., via microservice generation system 102) operatively coupled to a processor (e.g., processor 106, quantum processor, etc.) to learn cluster assignments (e.g., cluster assignments or graph embeddings of Java classes, or both) in a monolithic application (e.g., a monolith enterprise application) based on runtime traces (e.g., the runtime traces described above with reference to FIGS. 1 and 3) of executed test cases (e.g., business functionality test cases executed using the monolithic application).

[0133] At 504, the computer-implemented method 500 can include using the model by a system (e.g., the microservice generation system 102 or the cluster component 110, or both) to generate clusters of classes based on the cluster assignments to identify one or more microservices of the monolithic application.

[0134] 6 illustrates a flow diagram of an example non-limiting computer-implemented method 600 that can facilitate the generation of microservices from a monolithic application based on runtime tracing in accordance with one or more embodiments described herein. Descriptions of each similar element or process or combination thereof utilized in each embodiment are omitted for purposes of brevity.

[0135] At 602, the computer-implemented method 600 may include collecting, by a system (e.g., the microservice generation system 102 or the collection component 202, or both) operatively coupled to a processor (e.g., the processor 106, a quantum processor, etc.), runtime traces (e.g., the runtime traces described above with reference to FIGS. 1 and 3) of test cases executed for a monolithic application (e.g., business functional test cases executed using a monolithic application such as a monolith enterprise application).

[0136] At 604, the computer-implemented method 600 may cause a system (e.g., via the microservice generation system 102) to train a model (e.g., model component 108, model 400, etc.) based on the runtime traces to learn cluster assignments (e.g., cluster assignments or graph embeddings of Java classes, or both) for classes in the monolithic application.

[0137] At 606, the computer-implemented method 600 utilizes the model by the system (e.g., via the microservice generation system 102 or the cluster component 110, or both) to generate clusters of classes based on the cluster assignments to identify one or more microservices of the monolithic application.

[0138] 7 illustrates a flow diagram of an example non-limiting computer-implemented method 700 that can facilitate the generation of microservices from a monolithic application based on runtime tracing in accordance with one or more embodiments described herein. Descriptions of each similar element or process or combination thereof utilized in each embodiment are omitted for purposes of brevity.

[0139] At 702, the computer-implemented method 700 may include training (e.g., microservice generation system 102) a model (e.g., model component 108, model 400, etc.) to learn cluster assignments or graph embeddings, or both, of Java classes in a monolithic application (e.g., a monolith enterprise application) based on runtime traces (e.g., the runtime traces described above with reference to FIGS. 1 and 3) of business functionality test cases executed using the monolithic application.

[0140] At 704, the computer-implemented method 700 may include utilizing the model (e.g., via the microservice generation system 102 or the cluster component 110, or both) to generate clusters of Java classes based on cluster assignments or graph embedding, or both.

[0141] At 706, the computer-implemented method 700 may include determining whether one or more microservice candidates for the monolithic application are identified (e.g., via the microservice generation system 102, the model component 108, or the cluster component 110, or a combination thereof). For example, with reference to the example trading application of FIG. 1 and described above, the cluster component 110 may utilize a trained version of the model component 108 to generate one or more positive sample pairs from the causal sequences, where such one or more positive sample pairs may constitute one or more possible microservice candidates for the monolithic application.

[0142] If, at 706, one or more potential microservice candidates for the monolithic application are identified, at 708, the computer-implemented method 700 can include refining (e.g., via refinement component 206) the one or more potential microservice candidates based on a data dependency graph or a static call graph or both (e.g., the data dependency graph or the static call graph or both described above with reference to FIG. 1, 2, or 3, or a combination thereof) to identify microservices for the monolithic application.

[0143] If, at 706, one or more potential microservice candidates for the monolithic application are not identified, at 710, the computer-implemented method 700 may include modifying (e.g., via the microservice generation system 102 or the model component 108, or both) a window size used by the model (e.g., a window size described above with reference to FIG. 1 that can be used to generate one or more positive sample pairs that can constitute one or more potential microservice candidates for the monolithic application), or running (e.g., via the microservice generation system 102 or the collection component 202, or both) different business functionality test cases (e.g., business functionality test cases other than those described above with reference to FIG. 1) using the monolithic application, or both. For example, at 710, the computer-implemented method 700 may include modifying a window size used by the model from, e.g., window size 3 to, e.g., window size 4.

[0144] At 712, the computer-implemented method 700 may include retraining the model (e.g., by the microservices generation system 102) based on the runtime traces of the different business function test cases executed at 710, or the modified window size, or both, to learn cluster assignments and / or graph embeddings of Java classes in the monolithic application.

[0145] For ease of explanation, the computer-implemented methodologies are depicted and described as a series of acts. It should be understood and appreciated that the subject innovation is not limited by the acts depicted or by the order of acts or combinations thereof, for example, acts can occur in various orders, or simultaneously, or in combinations thereof, and with other acts not shown and described herein. Moreover, not all of the acts depicted are required to implement a computer-implemented methodology in accordance with the disclosed subject matter. Additionally, those skilled in the art will understand and appreciate that a computer-implemented methodology may alternatively be represented as a series of interrelated states via a state diagram or events. Additionally, it should be further appreciated that the computer-implemented methodologies disclosed below and throughout this specification can be stored on an article of manufacture that facilitates delivery and transfer of such computer-implemented methodologies to a computer. As used herein, the term article of manufacture is intended to encompass a computer program accessible from any computer-readable device or storage medium.

[0146] To provide a context for various aspects of the presently disclosed subject matter, in addition to the discussion below, Figure 8 is intended to provide a general description of a suitable environment in which various aspects of the presently disclosed subject matter may be implemented. Figure 8 illustrates a block diagram of an example non-limiting operating environment that may facilitate one or more embodiments described herein. Descriptions of each of the similar elements or processes or combinations thereof utilized in each embodiment are omitted for purposes of brevity.

[0147] 8, a suitable operating environment 800 for implementing various aspects of the present disclosure may also include a computer 812. The computer 812 may also include a processing unit 814, a system memory 816, and a system bus 818. The system bus 818 couples system components including, but not limited to, the system memory 816 to the processing unit 814. The processing unit 814 may be any of a variety of available processors. Dual microprocessors and other multi-processor architectures may also be utilized as the processing unit 814. The system bus 818 may be any of several types of bus structure(s), including a memory bus or memory controller, a peripheral bus or external bus, or any of a variety of available bus architectures, including, but not limited to, Industrial Standard Architecture (ISA), Micro Channel Architecture (MCA), Extended ISA (EISA), Intelligent Drive Electronics (IDE), VESA Local Bus (VLB), Peripheral Component Interconnect (PCI), Card Bus, Universal Serial Bus (USB), Advanced Graphics Port (AGP), Firewire (IEEE 1394), and Small Computer System Interface (SCSI).

[0148] The system memory 816 may also include volatile memory 820 and non-volatile memory 822. A basic input / output system (BIOS), containing the basic routines for transferring information between elements within the computer 812, such as during start-up, is stored in the non-volatile memory 822. The computer 812 may also include removable / non-removable, volatile / non-volatile computer storage media. FIG. 8 illustrates, for example, disk storage 824. The disk storage 824 may also include, but is not limited to, a magnetic disk drive, a floppy disk drive, a tape drive, a Jaz drive, a Zip drive, an LS-100 drive, a flash memory card, or a memory stick. The disk storage 824 may also include storage media, either separately or in combination with other storage media. An interface, such as a removable or non-removable interface 826, is typically used to facilitate coupling of the disk storage 824 to the system bus 818. FIG. 8 also illustrates software acting as an intermediary between a user and the basic computer resources described in the preferred operating environment 800. Such software may also include, for example, an operating system 828. The operating system 828 may be stored on disk storage 824 and operates to control and allocate resources of the computer 812.

[0149] System applications 830 benefit from the management of resources by operating system 828 through program modules 832 and program data 834 stored, for example, in either system memory 816 or disk storage 824. It should be appreciated that the present disclosure may be implemented with various operating systems or combinations of operating systems. A user enters commands or information into computer 812 through input device(s) 836. Input devices 836 include, but are not limited to, pointing devices such as a mouse, trackball, or stylus, touch pad, keyboard, microphone, joy stick, game pad, satellite dish, scanner, TV tuner card, digital camera, digital video camera, web camera, and the like. These and other input devices connect to processing unit 814 through system bus 818 via interface port(s) 838. Interface port(s) 838 include, for example, a serial port, a parallel port, a game port, and a universal serial bus (USB). The output device(s) 840 use some of the same types of ports as the input device(s) 836. Thus, for example, a USB port can be used to provide input to the computer 812 as well as to provide output information from the computer 812 to the output device 840. Output adapter 842 is provided to illustrate that there are some output devices 840 that require special adapters, such as monitors, speakers, and printers, among other output devices 840. Output adapter 842 includes, by way of example and not limitation, video and sound cards that provide a means of connection between the output device 840 and the system bus 818. Other devices or systems of devices, or combinations thereof, should be noted that provide both input and output capabilities, such as the remote computer(s) 844.

[0150] The computer 812 can operate in a networked environment using logical connections to one or more remote computers, such as remote computer(s) 844. The remote computer(s) 844 can be a computer, a server, a router, a network PC, a workstation, a microprocessor-based device, a peer device or other common network node, and typically also include many or all of the elements described for the computer 812. For purposes of simplicity, only a memory storage device 846 is shown for the remote computer(s) 844. The remote computer(s) 844 are locally connected to the computer 812 via a network interface 848, which is then physically connected via a communication connection 850. The network interface 848 may span a wired or wireless or both communication network, such as a local area network (LAN), a wide area network (WAN), a cellular network, and the like. LAN technologies include Fiber Distributed Data Interface (FDDI), Copper Distributed Data Interface (CDDI), Ethernet, Token Ring, etc. WAN technologies include, but are not limited to, point-to-point links, Integrated Services Digital Networks (ISDN) and variations thereon, packet switched networks, and Digital Subscriber Lines (DSL). Communications connection(s) 850 refers to the hardware / software utilized to connect the network interface 848 to the system bus 818. Although communications connection 850 is shown within computer 812 for illustrative clarity, it can also be external to computer 812.The hardware / software for connecting to the network interface 848 may also include, by way of example only, internal and external technologies such as modems, including telephone-grade modems, cable modems, and DSL modems, ISDN adapters, and Ethernet cards.

[0151] Referring now to FIG. 9, an exemplary cloud computing environment 950 is illustrated. As shown, the cloud computing environment 950 includes one or more cloud computing nodes 910 with which local computing devices used by cloud consumers communicate, such as a personal digital assistant (PDA) or cellular phone 954A, a desktop computer 954B, a laptop computer 954C, or an automobile computer system 954N, or combinations thereof. Although not shown in FIG. 9, the cloud computing nodes 910 may further include a quantum platform (e.g., quantum computer, quantum hardware, quantum software, etc.) that may communicate with the local computing devices used by the cloud consumers. The nodes 910 may communicate with each other. They may be physically or virtually grouped (not shown) in one or more networks, such as a private, community, public, or hybrid cloud, or combinations thereof, as described above. This allows the cloud computing environment 950 to provide an infrastructure, platform, or software-as-a-service for cloud consumers that eliminates the need to maintain resources on local computing devices. It will be understood that the types of computing devices 954A-N shown in Figure 9 are for illustrative purposes only, and that the computing nodes 910 and the cloud computing environment 950 can communicate with any type of computerized device through any type of network or addressable network connection (e.g., using a web browser), or both.

[0152] 10, a set of functional abstraction layers provided by cloud computing environment 950 (FIG. 9) is shown. It should be understood that the components, layers, and functions shown in FIG. 10 are intended to be illustrative only, and that embodiments of the present invention are not limited thereto. As shown, the following layers and corresponding functions are provided:

[0153] The hardware and software layer 1060 includes hardware and software components. Examples of the hardware components can include a mainframe 1061, a plurality of servers based on a RISC (reduced instruction set computer) architecture 1062, a plurality of servers 1063, a plurality of blade servers 1064, a plurality of storage devices 1065, and a network and networking component 1066. In some embodiments, the software components can include network application server software 1067 and database software 1068, quantum platform routing software (not shown in FIG. 10), or quantum software (not shown in FIG. 10), or a combination thereof.

[0154] The visualization layer 1070 provides an abstraction layer from which embodiments of virtual entities, described below, are provided; virtual servers 1071; virtual storage 1072; virtual networks 1073, including virtual private networks; virtual applications and operating systems 1074; and virtual clients 1075.

[0155] In one embodiment, the management layer 1080 may provide the following functions: Resource provisioning 1081 provides dynamic acquisition of computing resources and other resources used to perform tasks within the cloud computing environment. Metering and pricing 1082 provides cost tracking as resources are used within the cloud computing environment and provides billing or charging for the consumption of these resources. In one embodiment, these resources may include application software licenses. Security provides identification and authentication of cloud consumers and tasks as well as protection of data and other resources. User portal 1083 provides accessibility to the cloud computing environment and system administrators for consumers. Service level management 1084 provides allocation and management of cloud computing resources to meet required service levels. Service level agreement (SLA) planning and fulfillment 1085 provides pre-provisioning and acquisition of cloud computing resources as future demand requires according to SLAs.

[0156] The workload layer 1090 provides examples of functionality for utilizing a cloud computing environment. Non-limiting examples of workloads and functionality provided by this layer may include mapping and navigation 1091, software development and lifetime management 1092, virtual classroom instruction delivery 1093, data analytics processing 1094, transaction processing 1095, and microservices generation software 1096.

[0157] The present invention may be a system, a method, or a computer program product, or a combination thereof, at any possible level of technical detailed integration. The computer program product may include a recording medium (or media) having computer-readable program instructions thereon for causing a processor to perform features of the present invention. A computer-readable recording medium may be a tangible device capable of holding and storing a plurality of instructions for use by an instruction execution device. A computer-readable medium may be, for example, but not limited to, an electronic recording device, a magnetic recording device, an optical recording device, an electronic magnetic recording device, a semiconductor recording device, or any suitable combination thereof. Non-limiting examples of computer readable storage media include the following: portable computer disks, hard disks, random access memory (RAM), read only memory (ROM), erasable programmable read only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read only memory (CD-ROM), digital versatile disk (DVD), memory stick, floppy disk, punch cards or mechanically encoded devices having protruding structures in grooves having instructions recorded therein, and any suitable combination thereof. As used herein, computer readable storage media is not to be construed as a transitory signal per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves such as wave guides or other communications media (e.g., light pulses passing through fiber optic cable), or electrical signals communicated through wires.

[0158] The computer programs described herein can be downloaded from a computer-readable recording medium into each computing / processing device, or can be downloaded to an external computer or external recording device via a network, such as the Internet, a local area network, a wide area network, or a wireless network, and combinations thereof. The network can include copper cables, fiber optics, wireless networks, routers, firewalls, switches, gateway computers, and edge servers, and combinations thereof. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and transfers the computer-readable program instructions into a computer-readable recording medium in each computing / processing device for storage. The computer readable program instructions for performing the operations of the present invention may be either source code or object code written in any combination of programming languages, including assembler instructions, Instruction Set Architecture (ISA) instructions, machine language instructions, machine dependent instructions, microcode, firmware instructions, state setting data, configuration data for an integrated circuit, or one or more procedural programming languages, such as Smalltalk®, object oriented programming languages ​​such as C++, the “C” programming language, or similar programming languages. The computer readable program instructions may be executed entirely on the user computer, partially on the user computer as a stand-alone software package, partially on the user computer and partially on a remote computer, or entirely on a remote computer or server.In the latter scenario, the remote computer can be connected to the user computer through any type of network, including a local area network (LAN), a wide area network (WAN), or the connection can be to an external computer (e.g., through an Internet service provider). In some embodiments, electronic circuitry, including, for example, programmable logic circuitry, a field programmable gate array (FPGA), or a programmable logic array (PLA), can execute computer readable program instructions and use state information of the computer readable program instructions to personalize the electronic circuitry to perform features of the present invention.

[0159] Aspects of the invention described herein have been described with reference to flowchart instructions and / or block diagrams of methods, devices (systems), and computer readable media and computer programs according to embodiments of the invention. It should be understood that any combination of the flowchart illustrations and / or block diagrams and / or blocks in the flowchart illustrations can be implemented by computer readable program instructions. These computer readable program instructions can be provided to a general purpose computer, a special purpose computer, or other processor or other programmable data processing device to produce a machine, and execution by the processor of the computer or other programmable data processing device produces means for implementing the functions / operations specified in the block or blocks of the flowcharts and / or block diagrams, or combinations thereof. These computer readable program instructions that instruct a computer, programmable data processing device, and / or other device to function in a particular manner can also be stored on a computer readable media, and a computer readable media having instructions stored therein constitutes an article of manufacture including instructions that implement the functional / operational features specified in the block or blocks of the flowcharts and / or block diagrams, or combinations thereof. The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device and cause a computer implemented process to perform a series of operational steps on the computer, other programmable apparatus, or other device to implement the functions / acts specified in the blocks of the flowcharts and block diagrams or in a combination thereof.

[0160] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and possible implementation operations of systems, methods, and computer program products according to various embodiments of the present invention. In this respect, the flowcharts or block diagrams may represent modules, segments, or portions of instructions, which include one or more executable instructions for implementing a particular logical function(s) (or functions). In some alternative implementations, the functions described in the blocks may be performed other than as illustrated. For example, two blocks shown in succession may be executed substantially simultaneously, or the blocks may be executed in reverse order, depending on the functionality involved. Also, the illustration of the blocks in the block diagrams and / or the illustration of the flowcharts or combinations thereof may be implemented by a system based on special purpose hardware that performs a particular function or operation or executes specific purpose hardware and computer instructions.

[0161] Although the subject matter of the present invention has been described above in the general context of computer-executable instructions for a computer program product running on a computer or multiple computers or combinations thereof, those skilled in the art will recognize that the present disclosure can also be implemented in combination with other program modules. Generally, program modules include routines, programs, components, data structures, etc. that perform particular tasks or implement particular abstract data types, or both. Furthermore, those skilled in the art will recognize that the inventive computer-implemented methods can be practiced with other computer system configurations including single-processor or multi-processor computer systems, minicomputing devices, computers as well as mainframe computers, handheld computing devices (e.g., PDAs, phones), microprocessor-based or programmable consumer or industrial electronics, etc. The illustrated aspects can be practiced in a distributed computing environment where tasks are performed by remote processing devices linked through a communications network. However, some, if not all aspects of the present disclosure can be practiced on a stand-alone computer. In a distributed computing environment, program modules can be located in local or remote memory storage devices. For example, in one or more embodiments, the computer-executable components may be executed from a memory that includes or comprises one or more distributed memory units. As used herein, the terms "memory" and "memory unit" are interchangeable. Furthermore, one or more embodiments herein may execute code of the computer-executable components in a distributed manner, e.g., multiple processors that combine or cooperate to execute code from one or more distributed memory units.The term "memory" as used herein may refer to a single memory at a single location or multiple memories or memory units at one or more locations.

[0162] As used in this application, the terms "component," "system," "platform," "interface," and the like, may refer to or encompass a computer-related entity or a machine-related entity that operates in one or more particular functions, or both. The entities disclosed herein may be either hardware, a combination of hardware and software, software, or software in execution. For example, a component may be, but is not limited to, a process running on a processor, a processor, an object, an executable, a thread of execution, a program, or a computer, or combinations thereof. By way of example, both an application running on a server and the server may be a component. One or more components may reside within a process or thread of execution, or both, and a component may be localized on one computer or distributed between two or more computers, or both. In another embodiment, each component executes from various computer readable media having various data structures stored thereon. A component may communicate via local or remote processes, such as signals having one or more data packets (e.g., one component interacting with another component in a local system, across a network with other systems via signals, such as a distributed system or the Internet, or both). As another example, a component may be a device having a particular function with mechanical parts operated by electrical or electronic circuits, which are operated by software or firmware executed by a processor. In such cases, the processor may be internal or external to the device and may execute at least a portion of the software or firmware application.As yet another example, a component may be an apparatus that provides a particular electronic component without having mechanical parts, where the electronic component may include a processor or other means for executing software or firmware that provides at least a portion of the functionality of the electronic component. In an aspect, a component may emulate the electronic component via a virtual machine, for example within a cloud computing system.

[0163] Additionally, the term "or" is intended to mean an inclusive "or" rather than an exclusive "or." That is, unless otherwise specified or clear from the context, "X utilizes A or B" is intended to mean any of the natural inclusive permutations. That is, if X utilizes A; X utilizes B; or X utilizes both A and B, then "X utilizes A or B" is satisfied under any of the foregoing examples. Furthermore, the articles "a" and "an" as used in the subject specification and the accompanying drawings are generally construed to mean "one or more," unless otherwise specified or clear from the context that they are singular. As used herein, the terms "embodiment" or "exemplary" or both are used to mean serving as an example, example, or illustration. For the avoidance of doubt, the subject matter disclosed herein is not limited by such embodiments. Additionally, any aspect or design described herein as "embodiment" or "exemplary" or both is not necessarily to be construed as preferred or advantageous over other aspects or designs, and is not meant to exclude equivalent exemplary structures and techniques known to those skilled in the art.

[0164] As used in the subject specification, the term "processor" may refer to virtually any computing processing unit or device, including, but not limited to, a single-core processor; a single processor with software multithreading execution capabilities; a multi-core processor with software multithreading execution capabilities; a multi-core processor with hardware multithreading techniques; and a parallel platform with distributed shared memory. Additionally, a processor may refer to an integrated circuit, an application specific integrated circuit (ASIC), a digital signal processor (DSP), a field programmable gate array (FPGA), a programmable logic controller (PLC), a complex programmable logic device (CPLD), discrete gate or transistor logic, discrete hardware components, or any combination thereof designed to perform the functions described herein. Furthermore, a processor may implement nano-scale architectures, such as, but not limited to, molecular and quantum dot-based transistors, switches, and gates to optimize space utilization or improve user-installed performance. A processor may also be implemented as a combination of computing processing units. In this disclosure, terms such as "store," "record," "data store," "data storage," "database," and substantially any other information storage component related to the operation and functionality of the component are used to refer to a "memory component," an entity embodied in "memory," or a component that includes memory. Memory and / or memory components described herein can be either volatile memory or non-volatile memory, or can include both volatile and non-volatile memory.By way of example, and not limitation, non-volatile memory may include read only memory (ROM), electrically programmable ROM (PROM), electrically erasable ROM (EEPROM), flash memory, or non-volatile random access memory (RAM) (e.g., ferroelectric RAM (FeRAM)). Volatile memory may include RAM, which may act as, for example, external cache memory. By way of example, and not by way of limitation, RAM is available in many forms, such as synchronous RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDR SDRAM), enhanced SDRAM (ESDRAM), SyncLink DRAM (SLDRAM), direct Rambus RAM (DRRAM), direct Rambus dynamic RAM (DRDRAM), and Rambus dynamic RAM (RDRAM). Additionally, the disclosed memory components of systems or computer-implemented methods herein are intended to include, without being limited to, these and any other suitable types of memory.

[0165] What has been described above includes merely examples of systems and computer-implemented methods. Of course, it is not possible to describe every conceivable combination of components or computer-implemented methods for purposes of describing the present disclosure, but one of ordinary skill in the art can recognize that many further combinations and permutations of the present disclosure are possible. Moreover, to the extent that the terms "including," "having," "possessing," and the like are used in the detailed description, claims, appendices, and drawings, such terms are intended to be inclusive in a manner similar to the term "comprising," as "including" would be interpreted when used as a replacement word in the claims.

[0166] The description of various embodiments has been presented for illustrative purposes, but is not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope of the described embodiments. The terms used in this specification are selected to best explain the principles of the embodiments, practical applications, or technical improvements over the art found in the market, or to enable others skilled in the art to understand the embodiments disclosed herein.

Claims

1. 1. A system comprising: a memory for storing computer-executable components; and a processor for executing the computer-executable components stored in the memory, the computer-executable components comprising: a model component that learns cluster assignments for classes in a monolithic application based on runtime traces of executed test cases; and a cluster component that utilizes the model component to generate clusters of the classes based on cluster assignments to identify one or more microservices of the monolithic application. A system including:

2. The computer executable components include: a refinement component that refines the one or more microservices based on at least one of data dependencies of the monolithic application or a static call graph of the monolithic application. The system of claim 1 , comprising:

3. The computer executable components include: a second model component that generates one or more causal graphs based on the runtime traces of the executed test cases to capture at least one of first order or higher order temporal dependencies of the monolithic application or at least one of the cluster assignments in the monolithic application. The system of claim 1 , comprising:

4. The model component learns at least one of a cluster assignment or a graph embedding of the classes in the monolithic application using causal sequences of one or more causal graphs generated based on the runtime traces of the executed test cases. The system of claim 1 .

5. The executed test cases include business functionality test cases that provide a business functionality of the monolithic application in the runtime trace, thereby facilitating at least one of performance improvement, efficiency improvement, or computational cost reduction of the processor or the system in performing application modernization of the monolithic application. The system of claim 1 .

6. The computer-executable components further include a collection component that collects runtime traces of test cases executed on the monolithic application. The system of claim 1 .

7. 1. A computer-implemented method, comprising: training a model with a system operatively coupled to the processor to learn cluster assignments for classes in the monolithic application based on run-time traces of executed test cases; and Utilizing the model, the system generates clusters of the classes based on the cluster assignments to identify one or more microservices of the monolithic application.

4. A computer-implemented method comprising:

8. moreover, refining, by the system, the one or more microservices based on at least one of data dependencies of the monolithic application or a static call graph of the monolithic application. The computer-implemented method of claim 7 , comprising:

9. moreover, generating, by the system, one or more causal graphs based on the runtime traces of the executed test cases to capture at least one of first order or higher order temporal dependencies of the monolithic application or at least one of the cluster assignments in the monolithic application; The computer-implemented method of claim 7 , comprising:

10. The training comprises: training a model by the system to learn at least one of cluster assignments or graph embeddings of the classes in the monolithic application using causal sequences of one or more causal graphs generated based on the runtime traces of the executed test cases. The computer-implemented method of claim 7 , comprising:

11. The executed test cases include business functionality test cases that provide a business functionality of the monolithic application in the runtime trace, thereby facilitating improving performance, improving efficiency, or reducing computational costs of at least one of the processor or the system in performing application modernization of the monolithic application.

8. The computer-implemented method of claim 7.

12. and collecting run-time traces of test cases executed on the monolithic application by a system operatively coupled to the processor. The computer-implemented method of claim 7 , comprising:

13. 1. A computer program product for facilitating generation of microservices from a monolithic application based on runtime tracing, the computer program product comprising: Training the model to learn cluster assignments for classes in the monolithic application based on runtime traces of executed test cases; and Utilizing a model to generate clusters of the classes based on the cluster assignments to identify one or more microservices of the monolithic application. A computer program that executes the following:

14. The computer includes: refining the one or more microservices based on at least one of data dependencies of the monolithic application or a static call graph of the monolithic application.

14. The computer program product of claim 13, further comprising:

15. The computer includes: generating one or more causal graphs based on the runtime traces of the executed test cases to capture at least one of first order or higher order temporal dependencies of the monolithic application or at least one of the cluster assignments in the monolithic application; 14. The computer program product of claim 13, further comprising:

16. The computer includes: training a model to learn at least one of cluster assignments or graph embeddings of the classes in the monolithic application using causal sequences of one or more causal graphs generated based on the runtime traces of the executed test cases; 14. The computer program product of claim 13, further comprising:

17. The executed test cases include business functionality test cases that provide business functionality of the monolithic application in the runtime trace.

14. A computer program product according to claim 13.

Images