An optimization method, device and medium for an application generated based on a low-code platform

Abstract

The application discloses an optimization method, device and medium for an application generated based on a low-code platform, and relates to the technical field of data processing. The method comprises the following steps: redundancy elimination, performance optimization and security reinforcement are performed on the code generated by the low-code platform by adopting a mechanism combining static analysis and dynamic analysis; real-time monitoring and bottleneck diagnosis are realized on the running state of the low-code application by monitoring the injection of a buried point, link tracking and time sequence prediction. The problems that the code generated by the existing low-code platform has redundancy, is difficult to be deeply optimized and lacks runtime performance insight are solved, and the code quality and runtime performance of the low-code application are improved.

Description

Technical Field

[0001] This application relates to the field of data processing technology, and in particular to an optimization method, device and medium for applications generated based on a low-code platform. Background Technology

[0002] Low-code platforms significantly reduce the barrier to entry and development cycle of application development through visual development models. However, as the applications hosted on low-code platforms become increasingly complex, the amount of code generated during application building also increases exponentially, resulting in poor code quality and insufficient performance during execution.

[0003] Therefore, providing a method that can ensure code quality and code performance throughout the entire lifecycle of a low-code platform is a problem that urgently needs to be solved. Summary of the Invention

[0004] This application provides an optimization method, device, and medium for applications generated based on a low-code platform. The main purpose is to solve the problem that the code generated by the low-code platform in the prior art is of poor quality and has insufficient performance during execution.

[0005] In a first aspect, embodiments of this application provide an optimization method for an application generated based on a low-code platform. The method includes: after generating a target application based on a low-code platform, performing static syntax rule analysis and dynamic performance analysis on the code of the target application to obtain an optimization suggestion report. Based on the optimization suggestion report, the code is pre-optimized to obtain the optimized target application; After deploying the optimized target application in the production environment, the raw observable data generated during operation is collected through the preset monitoring points in the optimized target application. A distributed request call chain is constructed based on the original observable data, and code performance bottleneck analysis is performed on the distributed request call chain based on the anomaly detection model and the time series prediction model to obtain the root cause node of the code performance bottleneck, so as to optimize the code of the optimized target application according to the root cause node.

[0006] In one implementation of this application, the step of performing static syntax rule analysis and dynamic performance analysis on the code of the target application to obtain an optimization suggestion report includes: Based on code pattern recognition mechanism, data flow analysis mechanism and security rule auditing mechanism, static syntax rule analysis is performed on the code of the target application to output first optimization suggestions including redundant fragments and security vulnerabilities of the target application code; During the test run phase of the target application, dynamic analysis probes are used to collect runtime performance metrics of the target application, including function execution time, memory allocation, and database access patterns. Based on a machine learning model, dynamic performance analysis is performed on the performance indicators to obtain a second optimization suggestion. The optimization suggestion report is generated by combining the first optimization suggestion and the second optimization suggestion.

[0007] In one implementation of this application, constructing a distributed request call chain based on the original observable data includes: Aggregate raw observable data with the same tracking identifier to obtain at least one aggregated group, wherein the raw observable data under the same request have the same tracking identifier; Based on the reference relationship between the span identifier of each original observable data in each aggregation group and its respective parent span identifier, the original observable data in each aggregation group are aggregated into the distributed request call chain with a hierarchical structure.

[0008] In one implementation of this application, the step of performing code performance bottleneck analysis on the distributed request call chain based on an anomaly detection model and a time-series prediction model to obtain the root cause node of the code performance bottleneck includes: Based on the anomaly detection model and the time-series prediction model, the call chain and the performance indicators are jointly analyzed to obtain the root cause node of the code performance bottleneck; The root cause node and runtime effect feedback data are returned to the machine learning model to update the optimization strategy library of the machine learning model, so that the machine learning model can be adaptively iteratively enhanced.

[0009] In one implementation of this application, before deploying the optimized target application in the production environment, the method includes: The monitoring points are injected into the service call points, business logic entry points, and database operation points corresponding to the optimized target application through a bytecode enhancement mechanism.

[0010] In one implementation of this application, the step of performing pre-optimization on the code based on the optimization suggestion report to obtain the optimized target application includes: If the component properties or logic flow of the target application are optimized using a visual designer based on the optimization suggestion report, the code is updated synchronously according to the first optimization content to obtain the optimized target application; If the code is optimized according to the optimization suggestion report, the second optimization content is synchronously updated to the visual designer, and the optimized target application is obtained.

[0011] In one implementation of this application, synchronously updating the second optimized content to the visual designer includes: Determine whether there is a semantic conflict between the second optimization content and the first optimization content; If the semantic conflict exists, a target suggestion for adjusting the second optimization content is generated; The second optimization content is recommended to be adjusted according to the stated objectives; The code is optimized according to the adjusted second optimization content, and the adjusted second optimization content is synchronously updated to the visual designer; If no semantic conflict exists, the second optimization content will be synchronously updated to the visualization designer.

[0012] In one implementation of this application, the method includes: After each optimization, the code is uploaded to the version control system for historical version storage and rollback.

[0013] Secondly, embodiments of this application also provide an optimization device for applications generated based on a low-code platform. The device includes: at least one processor; and a memory communicatively connected to the at least one processor. The memory stores instructions executable by the at least one processor, which, when executed, enable the at least one processor to: perform static syntax rule analysis and dynamic performance analysis on the code of the target application after generating it based on the low-code platform, and obtain an optimization suggestion report; perform pre-optimization on the code according to the optimization suggestion report to obtain an optimized target application; after deploying the optimized target application in a production environment, collect raw observable data generated during operation through preset monitoring points in the optimized target application; construct a distributed request call chain based on the raw observable data, and perform code performance bottleneck analysis on the distributed request call chain based on an anomaly detection model and a timing prediction model to obtain the root cause node of the code performance bottleneck, so as to optimize the code of the optimized target application according to the root cause node.

[0014] Thirdly, embodiments of this application also provide an optimized non-volatile computer storage medium for applications generated based on a low-code platform, storing computer-executable instructions. These instructions are configured to: after generating a target application based on the low-code platform, perform static syntax rule analysis and dynamic performance analysis on the code of the target application to obtain an optimization suggestion report; perform pre-optimization on the code according to the optimization suggestion report to obtain an optimized target application; after deploying the optimized target application in a production environment, collect raw observable data generated during operation through preset monitoring points in the optimized target application; construct a distributed request call chain based on the raw observable data, and perform code performance bottleneck analysis on the distributed request call chain based on an anomaly detection model and a timing prediction model to obtain the root cause node of the code performance bottleneck, so as to optimize the code of the optimized target application according to the root cause node.

[0015] This application provides an optimization method, device, and medium for applications generated based on a low-code platform, which has the following beneficial effects: By employing a mechanism combining static and dynamic analysis, redundancy elimination, performance optimization, and security hardening are performed on the code generated by the low-code platform; through monitoring point injection, link tracing, and timing prediction, real-time monitoring and bottleneck diagnosis of the low-code application's runtime status are achieved. This solves the problems of redundancy, difficulty in deep optimization, and lack of runtime performance insight in code generated by existing low-code platforms, thereby improving the code quality and runtime performance of low-code applications. Attached Figure Description

[0016] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings: Figure 1 A flowchart illustrating an optimization method for an application generated based on a low-code platform, provided in this application embodiment; Figure 2 This is a schematic diagram of the internal structure of an optimized device for an application generated based on a low-code platform, provided as an embodiment of this application. Detailed Implementation

[0017] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions of this application will be clearly and completely described below in conjunction with specific embodiments and corresponding drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0018] This application provides an optimization method, device, and medium for applications generated based on a low-code platform, to solve the following technical problem: the code generated by the low-code platform in the prior art has poor quality and insufficient performance during execution.

[0019] The technical solutions proposed in the embodiments of this application will be described in detail below with reference to the accompanying drawings.

[0020] Figure 1 This document provides a flowchart of an optimization method for an application generated based on a low-code platform, as illustrated in an embodiment of this application. Figure 1 As shown in the figure, an optimization method for an application generated based on a low-code platform provided in this application embodiment specifically includes the following steps: Step 101: After generating the target application based on the low-code platform, perform static syntax rule analysis and dynamic performance analysis on the code of the target application to obtain an optimization suggestion report; As a refinement of the above embodiments, when performing static syntax rule analysis and dynamic performance analysis on the code of the target application in step 101 to obtain an optimization suggestion report, the following implementation methods can also be adopted, but are not limited to: performing static syntax rule analysis on the code of the target application based on code pattern recognition mechanism, data flow analysis mechanism and security rule auditing mechanism to output a first optimization suggestion including redundant fragments and security vulnerabilities of the target application code; during the test run phase of the target application, collecting runtime performance indicators of the target application through dynamic analysis probe, the performance indicators including function execution time, memory allocation and database access patterns; performing dynamic performance analysis on the performance indicators based on machine learning model to obtain a second optimization suggestion; and fusing the first optimization suggestion and the second optimization suggestion to generate the optimization suggestion report.

[0021] In some embodiments, when performing static syntax rule analysis, the following implementation methods may also be adopted, but are not limited to: scanning the code after code generation and before execution, using code pattern recognition mechanisms and data flow analysis mechanisms to check and eliminate invalid function calls, unused variables, and duplicate logical code segments in the code; simultaneously, based on the pre-built security rule library in the security rule audit mechanism, performing security audit on the code and suggesting remediation solutions to obtain the first optimization suggestion; when performing dynamic performance analysis, the following implementation methods may also be adopted, but are not limited to: during the test run phase of the target application, monitoring key performance indicators (such as function execution time, memory allocation, etc.) based on machine learning models; combined with the results of dynamic performance analysis, second optimization suggestions can be proposed for concurrency strategies (such as thread pool configuration), resource allocation (such as database connection pool), and logical branch structure, and even dynamic adjustments can be implemented in an environment that supports hot updates; the machine learning model has continuous learning capabilities and can continuously adjust the optimization strategy based on historical optimization records and running effect data to make it more suitable for the actual load and business characteristics of a specific application.

[0022] Furthermore, in one possible implementation of this application, the static syntax rule analysis further includes: integrating open-source static code analysis tools such as SonarQube and Checkstyle, and incorporating a custom rule library based on Abstract Syntax Tree (AST) analysis; after the low-code platform generates initial code (such as Java or JavaScript), a deep scan is initiated on the code using the integrated static code analysis tools and the custom rule library to identify features such as private methods that are never called, repetitive logical judgments, and mergeable database queries. For example, if string concatenation is detected within a loop, it will suggest using StringBuilder for optimization; in addition, a security rule library such as OWASP Top 10 is built-in; for example, when SQL statements generated by string concatenation are detected in the code, potential SQL injection vulnerabilities will be immediately marked, and it will be suggested to modify the code to use parameterized queries (PreparedStatement) or secure query methods provided by an ORM framework, thereby achieving complete static syntax rule analysis.

[0023] Furthermore, in one possible implementation of this application, the dynamic performance analysis further includes: in a dedicated testing environment, injecting a lightweight performance profiling tool into the target application through a Java Agent (for JVM applications) or similar bytecode enhancement technology; specifically, monitoring key performance indicators such as execution time, memory allocation, and database connection pool usage; under stress testing, if a query interface is found to be slow, and analysis of the call chain reveals an N+1 query problem, suggesting optimization using JOIN or Batch Fetching strategies; for high-concurrency scenarios, such as a flash sale system, by analyzing thread lock contention, if high contention is detected in a synchronized method, suggesting the use of finer-grained locks (such as ReentrantLock), lock-free data structures (such as ConcurrentHashMap), or asynchronous processing modes to improve system throughput. Static syntax rule analysis and dynamic performance analysis ensure the generation of correct, high-performance, and maintainable code.

[0024] Step 102: Perform preliminary optimization on the code based on the optimization suggestion report to obtain the optimized target application; As a refinement of the above embodiments, when performing step 102 to perform pre-optimization of the code based on the optimization suggestion report to obtain the optimized target application, the following implementation methods can also be adopted, but are not limited to: if the component attributes or logic flow of the target application are optimized using a visual designer based on the optimization suggestion report, then the code is updated synchronously according to the first optimization content to obtain the optimized target application; if the code is optimized based on the optimization suggestion report, then the second optimization content is updated synchronously to the visual designer to obtain the optimized target application.

[0025] As a refinement of the above embodiments, when executing the step of synchronously updating the second optimized content to the visual designer, the following implementation methods can also be adopted, but are not limited to: determining whether there is a semantic conflict between the second optimized content and the first optimized content; if the semantic conflict exists, generating a target suggestion to adjust the second optimized content; adjusting the second optimized content according to the target suggestion; optimizing the code according to the adjusted second optimized content, and synchronously updating the adjusted second optimized content to the visual designer; if there is no semantic conflict, synchronously updating the second optimized content to the visual designer. The aforementioned scheme achieves bidirectional synchronization and semantic conflict detection.

[0026] Furthermore, in one possible implementation of this application, the bidirectional synchronization and semantic conflict detection further include: when a user adjusts component properties or logic flow in the visual designer, these changes are reflected in the underlying source code in real time; conversely, modifications made to the source code by professional developers in the code editor are also synchronously updated on the visual canvas, ensuring consistency between the two views; when modifications on both sides may cause conflicts, the system performs semantic-level analysis, identifies the conflicts, and provides suggested solutions to assist users in decision-making and merging. Specifically, when business personnel drag and drop components to adjust the interface in the designer, the operation is serialized into a structured JSON. The schema operates on the object and sends it to the backend synchronization service in real time via a WebSocket connection. The synchronization service parses the operation and uses AST analysis technology to accurately locate the parts of the source code that need to be modified. When a potential conflict is detected (such as a business user deleting a button while the developer has just added complex event logic to that button), the system performs semantic-level analysis to identify that "the target of the event logic no longer exists," thus highlighting the conflict and suggesting that the developer "check and remove potentially invalid event handling functions" instead of simply merging text. This resolves the conflict between visual design and underlying code modification.

[0027] Step 103: After deploying the optimized target application in the production environment, collect the raw observable data generated during operation through the preset monitoring points in the optimized target application.

[0028] As a refinement of the above embodiments, before deploying the optimized target application in the production environment, the method may also adopt, but is not limited to, the following implementation methods, for example: injecting the monitoring points into the service call points, business logic entry points and database operation points corresponding to the optimized target application through a bytecode enhancement mechanism.

[0029] Step 104: Construct a distributed request call chain based on the original observable data, and perform code performance bottleneck analysis on the distributed request call chain based on the anomaly detection model and the time series prediction model to obtain the root cause node of the code performance bottleneck, so as to optimize the code of the optimized target application according to the root cause node.

[0030] As a refinement of the above embodiments, when constructing a distributed request call chain based on the original observable data in the execution step, the following implementation methods may also be adopted, but are not limited to: aggregating the original observable data with the same tracer identifier to obtain at least one aggregation group, wherein the original observable data under the same request have the same tracer identifier; and aggregating the original observable data in each aggregation group into a distributed request call chain with a hierarchical structure according to the reference relationship between the span identifier of each original observable data in each aggregation group and its respective parent span identifier.

[0031] As a refinement of the above embodiments, when performing the code performance bottleneck analysis of the distributed request call chain based on the anomaly detection model and the time-series prediction model to obtain the root cause node of the code performance bottleneck, the following implementation methods can also be adopted, but are not limited to: performing joint analysis of the call chain and the performance indicators based on the anomaly detection model and the time-series prediction model to obtain the root cause node of the code performance bottleneck; returning the root cause node and runtime effect feedback data to the machine learning model to update the optimization strategy library of the machine learning model, so that the machine learning model can adaptively iterate and enhance.

[0032] In some embodiments, the construction of the distributed request call chain further includes: assigning a unique trace ID to each external request and passing it between services; by collecting this information, a complete distributed request call chain can be constructed and presented in a visual form, clearly showing the services the request passes through, the time consumed at each stage, and the dependencies. The external request is the request instruction that invokes the optimized target application.

[0033] In some embodiments, the time series forecasting model may employ LSTM, which models collected historical performance metrics (such as CPU utilization and response time) to predict future resource usage trends and potential performance bottlenecks. The bytecode enhancement mechanisms include ASM and Byte Buddy.

[0034] To facilitate understanding of the root cause node determination process in the above embodiments, this embodiment takes inefficient pagination query as an example of a performance bottleneck, and provides an exemplary description including: assigning a unique Trace to each external request (such as an HTTP request). The ID is continuously transmitted within the service and across service calls (passed via HTTP headers) to connect the complete request path; the collected tracing data, i.e., the tracing identifier (Span), is sent to a distributed tracing system (such as Jaeger or Zipkin) for storage and indexing; operations personnel can clearly see on a visual interface which microservices a request passes through from the front end to the back end, and how long each service takes, quickly locating bottlenecks; it integrates Prometheus as a time-series database to store various performance metrics; importantly, it has a built-in time-series prediction model based on LSTM (Long Short-Term Memory network); this model learns from historical performance data (such as CPU utilization, memory usage, and interface response time) to predict future resource usage trends; for example, if it predicts that the CPU utilization of the order service has a 90% probability of exceeding 85% in the next two hours, the model will issue a capacity expansion warning to the operations team in advance, achieving proactive operations; in addition, it utilizes Isolation Forest. The anomaly detection model is constructed using unsupervised learning algorithms. Based on the anomaly detection model, it automatically detects anomalies in performance indicators that do not match the historical patterns in the future performance indicators output by the time series prediction model and immediately issues an alert. This eliminates the need to rely on manually set fixed thresholds, greatly improving the accuracy and timeliness of the alerts.

[0035] In some embodiments, the performance bottleneck includes N+1 database queries, highly contentious synchronization locks, or inefficient pagination logic; the second optimization suggestion includes using join queries, fine-grained locking, or cursor pagination strategies.

[0036] In some embodiments, after completing step 102 or step 104, the method further includes: uploading the optimized code to a version control system for historical version storage and rollback.

[0037] Furthermore, in one possible implementation of this application, the version storage and rollback can also be implemented in the following ways: all modifications to the code, regardless of their source, are managed through a version control service that encapsulates the underlying Git commands; each synchronization operation generates a commit with meaningful commit information (such as "updating username field label via designer"), providing a complete version history and rollback capability to conform to professional development process specifications.

[0038] In summary, the embodiments of this application can achieve the following effects, including: 1. By employing a mechanism combining static and dynamic analysis, redundancy elimination, performance optimization, and security hardening are performed on the code generated by the low-code platform. Real-time monitoring and bottleneck diagnosis of the low-code application's runtime status are achieved through monitoring point injection, link tracing, and timing prediction. This solves the problems of redundancy, difficulty in deep optimization, and lack of runtime performance insight in the code generated by existing low-code platforms, improving the code quality and runtime performance of low-code applications.

[0039] 2. Through AI-based autonomous learning capabilities, this method can continuously optimize its own strategies, enabling it to better adapt to the long-term evolution needs of specific application scenarios.

[0040] The above are embodiments of the method proposed in this application. Based on the same inventive concept, embodiments of this application also provide an optimized device for applications generated based on a low-code platform, the structure of which is as follows: Figure 2 As shown.

[0041] Figure 2 This is a schematic diagram of the optimized internal structure of a device for an application generated based on a low-code platform, provided as an embodiment of this application. For example... Figure 2 As shown, the device includes: At least one processor 201; And a memory 202 that is communicatively connected to at least one processor; The memory 202 stores instructions executable by at least one processor. These instructions are executed by at least one processor 201 to enable the processor 201 to: perform static syntax rule analysis and dynamic performance analysis on the code of the target application after generating it based on a low-code platform, and obtain an optimization suggestion report; perform pre-optimization on the code based on the optimization suggestion report to obtain an optimized target application; after deploying the optimized target application in a production environment, collect raw observable data generated during operation through preset monitoring points in the optimized target application; construct a distributed request call chain based on the raw observable data, and perform code performance bottleneck analysis on the distributed request call chain based on an anomaly detection model and a timing prediction model to obtain the root cause node of the code performance bottleneck, so as to optimize the code of the optimized target application based on the root cause node.

[0042] Some embodiments of this application provide corresponding to Figure 1A non-volatile computer storage medium stores computer-executable instructions, which are configured to: after generating a target application based on a low-code platform, perform static syntax rule analysis and dynamic performance analysis on the code of the target application to obtain an optimization suggestion report; perform pre-optimization on the code according to the optimization suggestion report to obtain an optimized target application; after deploying the optimized target application in a production environment, collect raw observable data generated during operation through preset monitoring points in the optimized target application; construct a distributed request call chain based on the raw observable data, and perform code performance bottleneck analysis on the distributed request call chain based on an anomaly detection model and a timing prediction model to obtain the root cause node of the code performance bottleneck, so as to optimize the code of the optimized target application according to the root cause node.

[0043] The various embodiments in this application are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the embodiments for IoT devices and media are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the descriptions of the method embodiments.

[0044] The systems, media, and methods provided in this application are one-to-one correspondences. Therefore, the systems and media also have similar beneficial technical effects as their corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the systems and media will not be repeated here.

[0045] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0046] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0047] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0048] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0049] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.

[0050] Memory may include non-persistent storage in computer-readable media, such as random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. Memory is an example of computer-readable media.

[0051] Computer-readable media include both permanent and non-permanent, removable and non-removable media that can store information by any method or technology. Information can be computer-readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, magnetic magnetic disk storage or other magnetic storage devices, or any other non-transferable medium that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transient computer-readable media, such as modulated data signals and carrier waves.

[0052] It should also be noted that the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0053] The above description is merely an embodiment of this application and is not intended to limit the scope of this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the scope of the claims of this application.

Claims

1. An optimization method for applications generated based on a low-code platform, characterized in that, The method includes: After generating the target application based on the low-code platform, static syntax rule analysis and dynamic performance analysis are performed on the code of the target application to obtain an optimization suggestion report; Based on the optimization suggestion report, the code is pre-optimized to obtain the optimized target application; After deploying the optimized target application in the production environment, the raw observable data generated during operation is collected through the preset monitoring points in the optimized target application. A distributed request call chain is constructed based on the original observable data, and code performance bottleneck analysis is performed on the distributed request call chain based on the anomaly detection model and the time series prediction model to obtain the root cause node of the code performance bottleneck, so as to optimize the code of the optimized target application according to the root cause node.

2. The optimization method for an application generated based on a low-code platform according to claim 1, characterized in that, The static syntax rule analysis and dynamic performance analysis performed on the code of the target application, resulting in an optimization suggestion report, include: Based on code pattern recognition mechanism, data flow analysis mechanism and security rule auditing mechanism, static syntax rule analysis is performed on the code of the target application to output first optimization suggestions including redundant fragments and security vulnerabilities of the target application code; During the test run phase of the target application, dynamic analysis probes are used to collect runtime performance metrics of the target application, including function execution time, memory allocation, and database access patterns. Based on a machine learning model, dynamic performance analysis is performed on the performance indicators to obtain a second optimization suggestion. The optimization suggestion report is generated by combining the first optimization suggestion and the second optimization suggestion.

3. The optimization method for an application generated based on a low-code platform according to claim 2, characterized in that, The construction of the distributed request call chain based on the original observable data includes: Aggregate raw observable data with the same tracking identifier to obtain at least one aggregated group, wherein the raw observable data under the same request have the same tracking identifier; Based on the reference relationship between the span identifier of each original observable data in each aggregation group and its respective parent span identifier, the original observable data in each aggregation group are aggregated into the distributed request call chain with a hierarchical structure.

4. The optimization method for an application generated based on a low-code platform according to claim 3, characterized in that, The code performance bottleneck analysis of the distributed request call chain based on the anomaly detection model and the time-series prediction model reveals the root cause nodes of the code performance bottleneck, including: Based on the anomaly detection model and the time-series prediction model, the call chain and the performance indicators are jointly analyzed to obtain the root cause node of the code performance bottleneck; The root cause node and runtime effect feedback data are returned to the machine learning model to update the optimization strategy library of the machine learning model, so that the machine learning model can be adaptively iteratively enhanced.

5. The optimization method for an application generated based on a low-code platform according to claim 1, characterized in that, Before deploying the optimized target application in the production environment, the method includes: The monitoring points are injected into the service call points, business logic entry points, and database operation points corresponding to the optimized target application through a bytecode enhancement mechanism.

6. The optimization method for an application generated based on a low-code platform according to claim 1, characterized in that, The step of performing pre-optimization on the code based on the optimization suggestion report to obtain the optimized target application includes: If the component properties or logic flow of the target application are optimized using a visual designer based on the optimization suggestion report, the code is updated synchronously according to the first optimization content to obtain the optimized target application; If the code is optimized according to the optimization suggestion report, the second optimization content is synchronously updated to the visual designer, and the optimized target application is obtained.

7. The optimization method for an application generated based on a low-code platform according to claim 6, characterized in that, Synchronizing and updating the second optimized content to the visual designer includes: Determine whether there is a semantic conflict between the second optimization content and the first optimization content; If the semantic conflict exists, a target suggestion for adjusting the second optimization content is generated; The second optimization content is recommended to be adjusted according to the stated objectives; The code is optimized according to the adjusted second optimization content, and the adjusted second optimization content is synchronously updated to the visual designer; If no semantic conflict exists, the second optimization content will be synchronously updated to the visualization designer.

8. The optimization method for an application generated based on a low-code platform according to claim 6, characterized in that, The method includes: After each optimization, the code is uploaded to the version control system for historical version storage and rollback.

9. An optimized device for applications generated based on a low-code platform, characterized in that, The device includes: At least one processor; And, a memory communicatively connected to the at least one processor; The memory stores instructions that can be executed by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform an optimization method for an application generated based on a low-code platform as described in any one of claims 1-8.

10. A computer storage medium storing computer-executable instructions, characterized in that, When the computer-executable instructions are executed, they implement an optimization method for an application generated based on a low-code platform as described in any one of claims 1-8.

Images