Integrated process script optimization using generative models

Abstract

Systems and methods include executing a script in an execution environment that implements a portion of a process that receives a message from a sender and sends the message to a recipient; determining resource consumption data indicating resource consumption in the execution environment during execution of the script in the execution environment; sending a prompt to the text generation model, wherein the prompt comprises the resource consumption data and the script; receiving, in response to the prompt, a response from the text generation model indicating one or more modifications to the script; and presenting the one or more modifications.

Description

Technical Field

[0001] This application relates to integrated process script optimization using generative models. Background Art

[0002] Modern organizations often utilize a system landscape consisting of one or more software applications executing within one or more computing environments. For example, an organization may use applications deployed on computer servers located in on-premise data centers and in data centers provided by one or more platform-as-a-service (PaaS) providers. Any of these computer servers may include cloud-based systems (e.g., using scalable-on-demand virtual machines to provide services).

[0003] Integration platforms facilitate message delivery between different software applications. For example, the integration platform can receive messages sent by one software application (i.e., the sender component) and route the messages to one or more software applications (i.e., the receiver components). The integration platform can perform various actions (e.g., splitting, transforming) on ​​the received messages before routing them to the receiver components.

[0004] The integration platform selects and executes an integration process in response to receiving a message. An integration process defines the actions to be performed in response to receiving a message from at least one specific sender component and intended for at least one specific receiver component. Different integration processes can be individually programmed and deployed based on the needs of the enterprise. Programming an integration process can consist of selecting and sequencing a set of predefined functional components. Some integration platforms support the inclusion of customer-developed scripts to execute operations within an integration process.

[0005] Typically, predefined functional components are tested and optimized by the integration platform provider for use within the platform. However, because the scripts are developed by the customer, even if the scripts are executable to perform their intended actions, they may exhibit suboptimal characteristics. These suboptimal characteristics may relate to non-functional requirements such as, but not limited to, resource consumption (e.g., memory, CPU, database), performance, fragility, and scalability. These risks can impact one or more integration scenarios, leading to failures in message processing or even downtime.

[0006] It is desirable for the system to efficiently improve the characteristics of scripts used within the integration process. Summary of the Invention

[0007] One aspect of the present disclosure provides a system comprising: a memory storing executable program code; and at least one processing unit configured to execute the program code so that the system: executes a script in an execution environment including a resource broker, the script implementing a portion of a process of receiving a message from a sender and sending the message to a receiver; determines, from the resource broker, resource consumption data associated with resource consumption of the execution environment during execution of the script in the execution environment; sends a prompt to a text generation model, the prompt including the resource consumption data and the script; receives, in response to the prompt, a response from the text generation model indicating one or more modifications to the script; and presents the one or more modifications.

[0008] In an example, the prompt includes a system prompt and a user prompt, and the at least one processing unit is configured to execute the program code to cause the system to: determine the system prompt from a plurality of system prompts based on the resource consumption data.

[0009] In an example, the at least one processing unit is to execute the program code to cause the system to: determine context data based on the resource consumption data; and populate the system prompt with the context data.

[0010] In an example, the at least one processing unit is to execute the program code to cause the system to: determine context data based on the resource consumption data; and populate the prompt with the context data.

[0011] In an example, the presentation of the one or more modifications includes presentation of a description of a code error.

[0012] In an example, the one or more modified presentations include presentation of a modified version of the script.

[0013] Another aspect of the present disclosure provides a method comprising: determining resource consumption data representing resource consumption in an execution environment due to execution of a script in the execution environment, the script implementing a portion of a process of receiving a message from a sender and sending the message to a recipient; sending a prompt to a text generation model, the prompt including the resource consumption data and the script; receiving a response from the text generation model in response to the prompt indicating one or more modifications to the script; and presenting the one or more modifications.

[0014] In an example, the prompt includes a system prompt and a user prompt, the method further comprising: determining the system prompt from a plurality of system prompts based on the resource consumption data.

[0015] In an example, the method further includes determining contextual data based on the resource consumption data; and populating the system prompt with the contextual data.

[0016] In an example, the method further includes determining context data based on the resource consumption data; and populating the prompt with the context data.

[0017] In an example, presenting the one or more modifications includes presenting a description of a code error.

[0018] In an example, presenting the one or more modifications includes presenting a modified version of the script.

[0019] Yet another aspect of the present disclosure provides a non-transitory medium storing program code executable by at least one processing unit of a computing system to cause the computing system to: determine resource consumption data indicating resource consumption in an execution environment due to execution of a script in the execution environment; send a prompt to a text generation model, the prompt including the resource consumption data and the script; receive a response from the text generation model in response to the prompt indicating one or more modifications to the script; and present the one or more modifications.

[0020] In an example, the prompt includes a system prompt and a user prompt, and the at least one processing unit is configured to execute the program code to cause the system to: determine the system prompt from a plurality of system prompts based on the resource consumption data.

[0021] In an example, the program code is executable by at least one processing unit of a computing system to cause the computing system to: determine context data based on the resource consumption data; and populate the system prompt with the context data.

[0022] In an example, the program code is executable by at least one processing unit of a computing system to cause the computing system to: determine context data based on the resource consumption data; and populate the prompt with the context data.

[0023] In an example, the presentation of the one or more modifications includes presentation of a description of a code error.

[0024] In an example, the one or more modified presentations include presentation of a modified version of the script. BRIEF DESCRIPTION OF THE DRAWINGS

[0025] Figure 1 is a block diagram of a system for optimizing integrated process scripts according to some embodiments.

[0026] Figure 2 is a logical view of an integration process according to some embodiments.

[0027] Figure 3 is a view of an interface of an integrated process script editor according to some embodiments.

[0028] Figure 4is a flowchart of a process for optimizing an integration process script according to some embodiments.

[0029] Figure 5 is a view of an interface of an integrated flow script editor presenting indications of script modifications according to some embodiments.

[0030] Figure 6 is a view of an interface of an integrated flow script editor presenting indications of script modifications according to some embodiments.

[0031] Figure 7 is a flowchart of a process for optimizing an integration process script according to some embodiments.

[0032] Figure 8 is a block diagram of a system for determining contextual data for a system prompt, according to some embodiments.

[0033] Figure 9 is a block diagram of an execution environment including integrated runtime and resource monitoring components according to some embodiments.

[0034] Figure 10 is a block diagram of a multi-tenant execution environment including a resource monitoring component, according to some embodiments.

[0035] Figure 11 is a block diagram of a cloud-based system for optimizing integration process scripts according to some embodiments. DETAILED DESCRIPTION

[0036] The following description is provided to enable any person skilled in the art to make and use the described embodiments. However, various modifications will be apparent to those skilled in the art.

[0037] Some embodiments may provide efficient optimization of integration process scripts. The optimization may include considering the script itself as well as characteristics observed during runtime processing of messages by the integration process including the script. The runtime characteristics may be used to generate system hints for a text generation model (such as a Large Language Model (LLM)) to determine efficient and actionable recommendations for optimizing the script.

[0038] Generating system prompts may include, but is not limited to, identifying knowledge base articles, component documentation, blogs, and the like associated with the runtime characteristics of the integration process script. Generating system prompts may also include selecting a system prompt template based on the runtime characteristics. Given the system prompts, the text generation model is better able to provide appropriate recommendations for improving the runtime characteristics of the integration process script. In some embodiments, recommendations may be provided in the form of modified code, line-of-code annotations, and / or text descriptions.

[0039] Thus, some embodiments facilitate the use of flexible programming languages ​​to define actions within an integration process.In addition, embodiments can identify problems with scripts that cannot be detected using manual inspection or conventional static code analysis tools.

[0040] Figure 1 is a block diagram of a system for optimizing integrated process scripts according to some embodiments. Each of the components shown can be implemented using any suitable combination of local, cloud-based, distributed (e.g., with distributed storage and / or computing nodes) computing hardware and / or software that is or becomes known. Each computing system described herein can include one or more physical and / or virtualized servers.

[0041] Design service 110 may include a system that provides a development environment to developers, such as developer 120. Design service 110 may include a general-purpose integrated development environment (IDE) and may support any programming language that is or becomes known. Design service 110 may support the development of artifacts for execution by a specific runtime (such as an integrated runtime in this example).

[0042] The design service 110 includes an integration flow designer 112, which is a software component used to design integration flows, according to some embodiments. An integration flow specifies the processing of messages from a sender to a receiver. Each sender and receiver can be assigned one or more integration flows, each of which processes one or more specific types of messages sent from the sender to the receiver. The same integration flow can be assigned to process messages between different sender and receiver pairs.

[0043] An integration process consists of a logical sequence of actions, where each action is implemented by predefined components, scripts, or a combination thereof. Figure 2 is a diagram of an integration process 200 according to some embodiments. Process 200 receives a message from a sender 210, performs processing actions, and sends three resulting messages to receiver applications 220 and 230. Embodiments are not limited to the structure or protocol of process 200.

[0044] Actions 202, 204, and 206 may comprise predefined components provided by the provider of the integration runtime. In this case, the designer of process 200 may specify configuration parameters for actions 202, 204, and 206. Action 208 is a mapping implemented by a script (such as, but not limited to, a Groovy script). The integration process designer 112 includes a script editor 113 that provides editing functionality. This editing functionality may include invoking a script checker component 114 to initiate one or more checks on the script being edited.

[0045] Figure 3 300 is a view of the interface 300 of the integrated process designer 112 including the script editor 113 according to some embodiments. The developer 120 can operate a web browser to access the integrated process designer 112 via a corresponding Uniform Resource Locator (URL), and the integrated process designer 112 returns an interface such as the interface 300.

[0046] Interface 300 presents a script 310 that can provide actions to be used in one or more integration flows. Script 310 can be created by a developer, such as developer 120. Interface 300 also includes an inspect control 320. According to some embodiments, inspect control 320 is selectable and is used to invoke the script inspector component 114. In some embodiments, other interfaces of the integration flow designer 112 are used to manage the deployment of integration flows that include script 310. Embodiments are not limited to the specific features of the integration flow designer 112 and script editor 113 described herein.

[0047] Return to Figure 1 , the execution environment 130 includes an integrated runtime 132, an application 134, and a resource agent 136. The execution environment 130 may include a cluster of one or more servers, virtual machines, container orchestration systems, etc. The execution environment 130 may provide an operating system, services, I / O, storage, libraries, frameworks, etc. to the services executed therein.

[0048] The integration runtime 132 may include components for executing integration flows 133. As is known in the art, integration flows 133 may be designed using the integration flow designer 112 and deployed to the runtime 132. Each integration flow 133 defines a sequence of actions and an executable component for performing each action, and one or more of the integration flows 133 includes an integration flow script that can be executed to perform the corresponding action. Executable components, including scripts, may be reused within more than one integration flow 133.

[0049] Integration processes 133 can be associated with specific senders, receivers, and message types. During runtime, the integration runtime 132 receives a message from a sender intended for a specific receiver. The integration runtime 132 identifies one of the integration processes 133 associated with the sender and receiver and passes the message to the identified integration process 133. The identified integration process 133 performs a sequence of actions based on the message and sends the message to the intended receiver. The sender and receiver can be one of the applications 134, 140, 142, and the data sources 144 and 146. Any number or type of senders / receivers can be associated with one or more of the integration processes 133.

[0050] The execution environment 130 includes a resource agent 136 for measuring the consumption of resources (e.g., CPU, memory, bandwidth) within the execution environment 130. The resource agent 136 can measure the resource consumption caused by executing the integration process script of the integration process 133. The resource agent 136 can be implemented in any manner that is or becomes known, such as using an API exposed by the execution environment 130 or a Prometheus monitoring system.

[0051] Resource agent 136 provides resource consumption data to service 150, which is stored in service 150 as resource consumption data 156. Service 150 also includes a code review resource database 157 and a prompt template 158. Code review resource database 157 may include a vectorized database for identifying resources for context enhancement, as described below. Such resources may be stored in a third-party repository (not shown) and may include, but are not limited to, knowledge base articles, wiki entries, and blogs.

[0052] Embodiments may efficiently determine modifications to the script using resource consumption data associated with runtime execution of an integration process script and corresponding code review resources 157 and hint templates 158. The modifications may be aimed at optimizing the script's resource consumption.

[0053] For example, in response to a design-time instruction to check an integration process script (e.g., received via the check control 320), the script checker component 114 can send a request including the script to the controller 152 of the service 150. The service 150 can be exposed to one or more instances of the design service 110 and instances of other design services.

[0054] The controller 152 invokes the prompt generator 154 to determine a system prompt for requesting a review of the integration process script. The prompt generator 154 generates the system prompt based on resource consumption data 156 associated with the execution of the integration process script using one of the prompt templates 158 and one or more of the code review resources 157. The resource consumption data 156 associated with the execution of the integration process script is received from the resource agent 136 during one or more previous executions of the integration process script within the execution environment 130.

[0055] The prompt generator 154 can select one of the prompt templates 158 and / or one or more of the code review resources 157 based on resource consumption data 156 associated with the execution of the integration process script. For example, the resource consumption data 156 can indicate high memory usage. Therefore, a prompt template in the prompt template 158 can be selected that includes text requesting that the integration process script be checked for memory consumption-related issues. Additionally or alternatively, one or more code review resources in the code review resources 157 can be selected that describe identification and resolution of memory consumption-related issues within the script. According to some embodiments, the selection of the prompt template 158 is not based on the resource consumption data 156 and / or the selection of one or more code review resources 157 is not based on the resource consumption data 156.

[0056] The prompt generator 154 sends the user prompts including the integrated process script and the generated system prompts to the application programming interface (API) proxy 160 of the trained text generation model 170. The text generation model 170 may include a neural network trained to generate text based on input text. The trained text generation model 170 can be implemented by, for example, executable program code, a set of hyperparameters defining the model structure and a set of corresponding weights, or any other representation of the input-output mapping learned as a result of training.

[0057] According to some embodiments, model 170 is a large language model (LLM) that conforms to a transformer architecture. The transformer architecture may include, for example, an embedding layer, a feedforward layer, a recurrent layer, and an attention layer. Generally speaking, each layer includes a node that receives an input, changes its internal state based on the input, and produces an output depending on the input and internal state. The outputs of some nodes are connected to the inputs of other nodes to form a directed and weighted graph. The weights and the functions that calculate the internal state are iteratively modified during training.

[0058] The embedding layer creates an embedding based on the input text, aiming to capture the semantic and syntactic meaning of the input text. The feedforward layer consists of multiple fully connected layers that transform the embedding. Some feedforward layers are designed to generate representations of the intent of the text input. The recurrent layer sequentially interprets the tokens (e.g., words) of the input text to capture the relationships between the tokens. The attention layer can adopt a self-attention mechanism that can consider different parts of the input text and / or the entire context of the input text to generate the output text.

[0059] Non-exhaustive examples of trained text generation models 170 include GPT-4, LaMDA, Claude, etc. Models 170 may be publicly available or deployed within a landscape trusted by the provider of service 150. Similarly, text generation models 170 may be trained based on public and / or private data.

[0060] The text generation model 170 generates a response based on the system prompt and the user prompt. The response may indicate one or more modifications to the integration process script. The indicated modifications may be intended to address any inappropriate resource consumption identified in the resource consumption data 156 associated with the execution of the integration process script. The response is returned to the script editor 113, and the one or more modifications may be displayed to the developer 120. The developer 120 may edit the script in light of the one or more modifications and deploy the modified script at runtime for use within the integration process 133 as described above.

[0061] Figure 4 A flowchart of a process 400 for optimizing an integrated process script according to some embodiments is included. Process 400 and other processes described herein can be performed using any suitable combination of hardware and software. The software program code implementing these processes can be stored by any non-transitory tangible medium (including a hard disk, volatile or non-volatile random access memory, DVD, flash drive, or tape) and executed by any one or more processing units (including but not limited to microprocessors, microprocessor cores, and microprocessor threads). Embodiments are not limited to the examples described below.

[0062] Prior to process 400, an integration process including an integration process script is created and deployed to a runtime environment (e.g., an integration runtime). During operation of the runtime environment (e.g., in a test or production environment), the integration process is executed to facilitate communication between a sender and a receiver. Execution of the integration process results in the execution of the integration process script at S410. S410 may include multiple executions of the integration process, and therefore, multiple executions of the integration process script.

[0063] At S420, resource consumption data associated with the execution of the script is determined. According to some embodiments, S420 may include monitoring resources (e.g., CPU cycles, CPU usage percentage, peak memory usage (raw and %), average memory usage (raw and %), bandwidth, database connection pool resources, data store size) consumed within the execution environment due to the execution of the integration process script (e.g., during the execution of the integration process script). S420 may include collecting resource consumption data over time (e.g., during multiple executions of the integration process script). The resource consumption data may be determined at S420 by a monitoring component of the execution environment, a monitoring component of the integration runtime, and any other suitable component.

[0064] Next, to review the integrated process script, at S430, the resource consumption data, context data, and script are sent to the trained test generation model. The context data can be provided in a system prompt and can indicate that the script is to be reviewed for errors and / or optimizations. The context data can also specify one or more types of errors and / or optimizations to be considered and can include information for identifying and / or resolving such errors and / or optimizations. This information can include knowledge base articles, blogs, etc.

[0065] At S440, a response is received from the text generation model. The response indicates one or more modifications to the integration process script. Depending on whether the request was prompted by the system, the response may also include an explanation of the one or more modifications. At S450, the one or more modifications are presented. The one or more modifications may be presented in any suitable manner.

[0066] Figure 5 is a view of an interface 300 according to some embodiments showing a script 310 and an indication 500 of the script modifications returned from the text generation model at S440. The indication 500 is presented via tabs entitled Memory Check, CPU Check, and Clean Code. The Memory Check tab is shown as Figure 5 shown as selected in .

[0067] In the illustrated embodiment, the memory check tag presents indications of script modifications related to memory usage. Each indication includes a description of the purpose of the modification, the original code to be modified, and the modified version of the original code. Figure 5 For example, the memory check tag indication 500 may also include the following content:

[0068] 3. Regular expressions can be used to split the data string into chunks instead of manually iterating and using indexOf. This can be more efficient and less error-prone:

[0069] / / Before optimization:

[0070] / / Manual splitting logic

[0071] / / After optimization:

[0072] def list = Data.split( / \s+ / )

[0073] Remember to make sure the regular expression (here, \s+) matches the expected format of the data exactly.

[0074] 4. When checking for file names or specific patterns, use the equals or startsWith methods instead of sub

[0075] String(substring) comparison to make the intent clearer and possibly improve performance:

[0076] / / Before optimization:

[0077] if(file.substring(0,12)=="FILE.XYZ1"){

[0078] / / After optimization:

[0079] if(file.startsWith("FILE.XYZ1")){

[0080] 5. Consider using regular expressions instead of loops when trimming leading zeros from MATNR

[0081] To replace leading zeros:

[0082]

[0083]

[0084] The CPU usage tag may present an indication of script modifications related to CPU performance. The clean code tag may present the original code modified to include one or more modifications. "Clean" code may be generated by applying a series of refactoring steps based on clean code principles and one or more script modifications to the original code. According to one example, Figure 5 The clean code rendered by the clean code tag can be read as follows:

[0085]

[0086]

[0087]

[0088] Figure 6 is a diagram of an interface 300 according to some embodiments, showing a script 610 and an indication 620 of script modifications returned from the text generation model at S440. The CPU checks the tag as Figure 6 The CPU Check tab presents indications of script modifications related to CPU usage, where each indication includes a description of the purpose of the modification, the original code to be modified, and the modified version of the original code.

[0089] Figure 7 FIG. 7 is a flow chart of a process 700 for optimizing an integration process script according to some embodiments. Process 700 may include an implementation of process 400, but embodiments are not limited thereto.

[0090] Initially, at S710, an integration process including an integration process script is operated in a runtime environment. The runtime environment may be a component of a landscape that includes tenant-operated integration middleware and the integration process deployed to the middleware. When a message is received from an associated sender, the integration process is operated to process the message and send the processed message to a receiver.

[0091] At S710, the operation of the integration flow results in the execution of the integration flow script. At S720, resource consumption data associated with the execution of the script is determined, for example, as described above with reference to S420. In some embodiments, S710 and S720 are performed independently and in parallel with each other and in parallel with the remaining steps of process 700.

[0092] At S730 , a determination is made as to whether a request to inspect the integration process script has been received. If not, the process returns to S710 to continue operating the integration process as needed and determine resource consumption data associated with the execution of the integration process script. The process loops through S710 , S720 , and S730 until a request to inspect the script is received.

[0093] In one example, as described above, a developer can operate the interface of the designer component to request an inspection of the script. Such a request is identified at S730, causing the process to proceed to S740. At S740, context data is determined based on the resource consumption data determined at S720. The determination of the context data may include the determination of a system prompt template and / or the determination of code review resources used to fill the system prompt template. In one example of the former, the determined resource consumption data may indicate high CPU usage. Therefore, S740 may include selecting a prompt template that includes text requesting an inspection of the integrated process script for CPU consumption related issues. In the latter example, several articles and blogs describing the identification and resolution of CPU consumption related issues may be located.

[0094] According to some embodiments, at S740 , context data is determined using a vector database that associates code review resources with embeddings generated from the resources. Figure 8 is a block diagram of a system that uses a vector database to determine contextual data for system prompts, according to some embodiments.

[0095] The database 840 stores code review resource embeddings 842. The code review resource embeddings 842 are multi-dimensional vector representations of various code review resources. Each of the embeddings 842 is associated with endpoint information, which can be used to retrieve the code review resource it represents.

[0096] Databases 850 and 860 store code review resources 852 and 862, respectively. Code review resources 852 and 862 may include knowledge base articles, blogs, wiki entries, and the like. Databases 850 and 860 may be owned and operated by different entities, including entities different from the entity that provides database 840. Databases 840, 850, and 860 may include any searchable data storage system, including but not limited to monolithic or distributed database systems.

[0097] In some embodiments of S740, the prompt generator 810 sends the resource consumption data 815 to the embedding generator 820. According to some embodiments, the resource consumption data 815 is or includes a summary of resource consumption generated based on the resource consumption data determined at S720. The summary can be generated based on the resource consumption data using a text generation model.

[0098] Embedding generator 820 may include any suitable component for mapping text into a multidimensional vector space. Embedding generator 820 may include the same component as that used to generate code review resource embedding 842 based on code review resources 852 and 862, or a component that uses a similar mapping. Embedding generator 820 generates and returns an embedding 830 corresponding to resource consumption data 815. Prompt generator 810 uses embedding 830 to query database 840 to determine code review resources related to embedding 830 and obtains those code review resources from database 850 and / or 860.

[0099] At S750, context data (in the form of system prompts), resource consumption data, and the script are sent to the trained test generation model. At S760, a response is received from the text generation model indicating one or more modifications to the integration process script. Then, at S770, the one or more modifications are presented in any suitable manner.

[0100] Figure 9 is a block diagram illustrating an example of an environment 900 including an integration runtime 910 according to some embodiments. In some examples, the environment 900 is a cloud environment, and the integration runtime 910 executes within a tenant at the cloud environment.

[0101] The environment 900 provides various computing resources 920-950 to the integration runtime 910 and other applications executing within the environment 900. During the execution of the integration process 912, the integration runtime 910 utilizes the computing resources 920-950 and the agents 913-916 track this usage. Thus, as described above, resource consumption data representing resource consumption associated with the execution of the integration process script of the integration process 912 can be collected for use by the prompt generator.

[0102] Memory agent 916 monitors requests by integration process 912 to access memory 950. Network agent 914 monitors requests by integration process 912 to use network resources 930. Storage agent 913 monitors requests by integration process 912 to use storage resources 920. CPU agent 915 monitors requests by integration process 912 to use CPU resources 940. Although different agents 913-916 are described as corresponding to specific resources 920-950, in some examples, a single agent can monitor the use of multiple different resources and / or multiple different resource types.

[0103] Figure 101 is a block diagram of a multi-tenant execution environment 1000 including a resource monitoring component according to some embodiments. Environment 1000 may include a public cloud environment that provides an integration platform according to a SaaS format. Environment 1000 includes tenants 1010, 1020, and 1030, each of which may execute one or more software applications provided to a client enterprise, for example, according to a SaaS arrangement.

[0104] Applications (not shown) executing at tenants 1010, 1020, 1030 can utilize public cloud environment computing resources, such as, for example, memory resources 1080, network resources 1060, data storage resources 1050, and / or CPU resources 1070. In some examples, environment 1000 can allocate or reserve portions of one or more computing resources for specific applications executing at one or more of tenants 1010, 1020, 1030.

[0105] Memory resources 1080 may include random access memory accessible to various applications executing at tenants 1010, 1020, 1030. Network resources 1060 may include network adapters, routers, switches, and / or other network devices available to applications executing at tenants 1010, 1020, 1030. In some examples, network resources 1080 may be described by available bandwidth.

[0106] Storage resources 1050 may include locations where applications executing at tenants 1010, 1020, and 1030 can store data. In some examples, storage resources 1050 may include disks or drives located at one or more servers that are also executing applications associated with one or more tenants 1010, 1020, and 1030. Storage resources 1050 may include one or more DBMSs provided for each tenant. The DBMSs may be executed on a common server for one or more of the tenants 1010, 1020, and 1030, or on one or more different servers.

[0107] CPU resources 1070 may be provided by one or more processors at one or more servers implementing environment 1000. The use of CPU resources 1070 may be described in terms of processor time, operations, and / or any other suitable metric. Environment 1000 may provide Figure 10 More or fewer resources as shown.

[0108] Each integration runtime 1015, 1025, 1035 manages messaging between two or more software components, such as a cloud application 1090, a locally executed application 1092, and a DBMS 1094. The cloud application 1090 may be executed in a cloud environment, such as a public cloud environment or a private cloud environment, including but not limited to the environment 1000. The integration runtime may manage messaging for more than a single cloud application.

[0109] Local applications 1092 are executed on a local computing system. For example, an enterprise utilizing local applications 1092 may maintain one or more servers, network device components, etc. to implement the local computing system. Local applications 1092 may be implemented by executing appropriate software on the local computing system. DBMS 1094 may be implemented, for example, in a cloud environment and / or in a local environment. DBMS 1094 may implement a database management system that may be associated with one or more client applications.

[0110] Each integration runtime 1015, 1025, 1035 can include one or more associated agents 1018, 1028, 1038. The agents 1018, 1028, 1038 can be configured to collect resource usage data describing resource usage resulting from the execution of the integration process scripts. The agents 1018, 1028, 1038 can also be configured to periodically provide resource usage data to a central service (not shown).

[0111] The agents 1018, 1028, 1038 may be configured to monitor resource requests made by the corresponding integration process scripts. For example, the agents 1018, 1028, 1038 may be configured to intercept requests for memory resources 1080, network resources 1060, storage resources 1050, and / or CPU resources 1070. The agents 1018, 1028, 1038 may maintain a record of resource requests and consumption by the integration process scripts and may periodically provide the resulting consumption data to an intermediate storage device.

[0112] Multi-tenant services 1040 provided by environment 1000 can be called and / or otherwise utilized by applications executing at more than one of tenants 1010, 1020, and 1030. Examples of multi-tenant services can include, for example, an agent 1048 for monitoring or managing resources 1050, 1060, 1070, and 1080. Multi-tenant services can include a scripting service for compiling dynamic scripts from an integration process and executing the dynamic scripts to return results to the calling integration process. A multi-tenant service mapping service can map message formats from one schema to another and can be accessible to integration processes in different tenants.

[0113] Figure 11 is a block diagram of a cloud-based system according to some embodiments. The design environment 1110, runtime environment 1130, service environment 1140, and text generation model 1150 can each include cloud-based resources, such as virtual machines, allocated by a cloud provider that provides self-service and just-in-time provisioning, automatic scaling, security, compliance, and identity management capabilities.

[0114] The user device 1120 can interact with a user interface of a design application executing in the design environment 1110, for example, via a web browser executing on the user device 1120. The design application can receive a request to inspect the integrated process script and can pass the request to the service environment 1140. The service environment 1140 determines resource consumption data associated with the execution of the script by the runtime environment 1130 and sends the resource consumption data, the script, and the context data to the text generation model 1150. In response, the service environment 1140 receives an indication of one or more modifications to the script, and the modifications are presented to the user device 1120 via the design environment 1110.

[0115] The aforementioned figures represent a logical architecture for describing the process according to some embodiments, and actual implementations may include more or different components arranged in other ways. Other topologies may be used in combination with other embodiments. In addition, each component or device described herein may be implemented by any number of devices communicating via any number of other public and / or private networks. Two or more of such computing devices may be located remotely from each other and may communicate with each other via any known network and / or dedicated connection mode. Each component or device may include any number of hardware and / or software elements suitable for providing the functions described herein and any other functions. For example, any computing device used in the implementation of some embodiments may include a processor to execute program code so that the computing device operates as described herein.

[0116] The embodiments described herein are for illustrative purposes only. Those skilled in the art will appreciate that other embodiments can be practiced by modifying and altering the above-described embodiments.

Claims

1. A system comprising: a memory for storing executable program codes; as well as at least one processing unit configured to execute the program code so that the system: executing a script in an execution environment including a resource agent, the script implementing a portion of a process of receiving a message from a sender and sending the message to a receiver; determining, from the resource agent, resource consumption data associated with consumption of resources of the execution environment during execution of the script in the execution environment; sending a prompt to a text generation model, the prompt including the resource consumption data and the script; receiving, in response to the prompt, a response from the text generation model indicating one or more modifications to the script; as well as The one or more modifications are presented.

2. The system according to claim 1, wherein: The prompts include system prompts and user prompts, and the at least one processing unit is configured to execute the program code to enable the system to: The system prompt is determined from a plurality of system prompts based on the resource consumption data.

3. The system of claim 2, wherein the at least one processing unit is configured to execute the program code to cause the system to: determining context data based on the resource consumption data; and The system prompt is populated with the contextual data.

4. The system of claim 1 , wherein the at least one processing unit is configured to execute the program code to cause the system to: determining context data based on the resource consumption data; and The prompt is populated with the context data.

5. The system according to claim 1, wherein: The presentation of the one or more modifications includes presentation of a description of a code error.

6. The system according to claim 1, wherein: The one or more modified presentations include presentation of a modified version of the script.

7. A method comprising: determining resource consumption data representing resource consumption in an execution environment resulting from executing a script in the execution environment, the script implementing a portion of a process of receiving a message from a sender and sending the message to a recipient; sending a prompt to a text generation model, the prompt including the resource consumption data and the script; receiving, in response to the prompt, a response from the text generation model indicating one or more modifications to the script; as well as The one or more modifications are presented.

8. The method according to claim 7, wherein: The prompt includes a system prompt and a user prompt, and the method further includes: The system prompt is determined from a plurality of system prompts based on the resource consumption data.

9. The method according to claim 8, further comprising: determining context data based on the resource consumption data; as well as The system prompt is populated with the contextual data.

10. The method according to claim 7, further comprising: determining context data based on the resource consumption data; as well as The prompt is populated with the context data.

11. The method according to claim 7, wherein: Presenting the one or more modifications includes presenting a description of a code error.

12. The method according to claim 7, wherein: Presenting the one or more modifications includes presenting a modified version of the script.

13. A non-transitory medium storing program code, the program code being executable by at least one processing unit of a computing system to cause the computing system to: determining resource consumption data indicating resource consumption in the execution environment due to execution of the script in the execution environment; sending a prompt to a text generation model, the prompt including the resource consumption data and the script; receiving, in response to the prompt, a response from the text generation model indicating one or more modifications to the script; as well as The one or more modifications are presented.

14. The medium according to claim 13, wherein The prompts include system prompts and user prompts, and the at least one processing unit is configured to execute the program code to enable the system to: The system prompt is determined from a plurality of system prompts based on the resource consumption data.

15. The medium of claim 14, the program code being executable by at least one processing unit of a computing system to cause the computing system to: determining context data based on the resource consumption data; and The system prompt is populated with the contextual data.

16. The medium of claim 13, the program code being executable by at least one processing unit of a computing system to cause the computing system to: determining context data based on the resource consumption data; and The prompt is populated with the context data.

17. The medium according to claim 13, wherein The presentation of the one or more modifications includes presentation of a description of a code error.

18. The medium according to claim 13, wherein The one or more modified presentations include presentation of a modified version of the script.

Images