Methods, apparatus, media, and program products for performing analytics tasks

Abstract

The application provides a method, device, electronic equipment, computer readable medium and computer program product for performing an analysis task. The method comprises: in response to triggering a target analysis task, obtaining task requirement information and generating a target file based on the task requirement information; calling an analysis planning module to generate an analysis planning file based on the target file, the analysis planning file containing a plurality of task nodes, each task node corresponding to an independent task execution module; for the plurality of task nodes in the analysis planning file, calling the corresponding task execution module node by node to execute the analysis task and generating and storing the analysis result; and generating an analysis report file of the target analysis task based on the analysis result of each task execution module. The application effectively solves the context overload problem of a large model in long process execution by splitting the entire analysis task process into a plurality of subtasks, each subtask being executed by an independent module, and storing the context by file respectively, thereby improving the stability and reliability of the entire system.

Description

Technical Field

[0001] This application relates to the field of computer technology, and more particularly to methods, apparatus, electronic devices, computer-readable media, and computer program products for performing analytical tasks. Background Technology

[0002] In software operations and development processes, the various metrics and charts provided by monitoring platforms are crucial for observing the operational status of server-side applications. For example, monitoring metrics may include HTTP request success rate, RPC latency, CPU and memory usage, container restart count, and garbage collection time, which are key to evaluating system performance and stability. Currently, this is generally done manually, meaning developers or operations engineers need to check each dashboard chart one by one to determine the system status or pinpoint the cause of problems. However, this method can be inefficient when dealing with a large number of metrics or rapidly changing issues, and it places high demands on the engineer's experience and focus.

[0003] Furthermore, existing intelligent alarm and indicator monitoring systems primarily focus on threshold-based triggering or statistical anomaly identification, exhibiting limitations in comprehensive attribution analysis across dimensions and charts. Moreover, current technologies need improvement in automating monitoring data processing, performing multi-dimensional analysis, and generating complete operational reports, particularly in addressing the context window limitations that large models may encounter when executing long-process tasks. Summary of the Invention

[0004] This application aims to provide a method, apparatus, electronic device, computer-readable medium, and computer program product for performing analysis tasks.

[0005] One aspect of this application provides a method for performing an analysis task, wherein the method includes:

[0006] In response to triggering a target analysis task, task requirement information is obtained and a target file is generated based on the task requirement information;

[0007] The analysis planning module is invoked to generate an analysis planning file based on the target file. The analysis planning file contains multiple task nodes, and each task node corresponds to an independent task execution module.

[0008] For multiple task nodes in the analysis planning document, the corresponding task execution module is called for each node to execute the analysis task and generate and store the analysis results;

[0009] Based on the analysis results obtained from each task execution module, an analysis report file for the target analysis task is generated.

[0010] In one aspect, this application provides an apparatus for performing an analysis task, wherein the apparatus includes:

[0011] The file generation module is used to respond to the triggering of a target analysis task, obtain task requirement information, and generate a target file based on the task requirement information.

[0012] The planning generation module is used to call the analysis planning module to generate an analysis planning file based on the target file. The analysis planning file contains multiple task nodes, and each task node corresponds to a specific task execution module.

[0013] The node analysis module is used to call the corresponding task execution module for each of the multiple task nodes in the analysis planning file to execute the analysis task, and generate and store the analysis results.

[0014] The report generation module is used to generate analysis report files for the target analysis task based on the analysis results obtained from each task execution module.

[0015] In another aspect of this application, an electronic device is provided, comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the methods of embodiments of this application.

[0016] In another aspect, this application provides a computer-readable storage medium having stored thereon computer program instructions that can be executed by a processor to implement the methods of the embodiments of this application.

[0017] Another aspect of this application provides a computer program product, including a computer program that, when executed by a processor, implements the methods of embodiments of this application.

[0018] The solution provided in this application breaks down the entire analysis task into multiple sub-tasks, each executed by an independent module, with each sub-task's context stored in a file. This effectively solves the problem of context overload in long-running large models, thereby improving the stability and reliability of the entire system. An analysis planning SubAgent is introduced, which automatically generates analysis planning files containing all nodes using a template-based approach. This achieves structured and reusable analysis tasks, improving the efficiency and accuracy of task planning. An image acquisition skill is used to call a headless browser to automatically take screenshots, and the results are then handed over to the large model's image understanding module for in-depth analysis. This improves the automation and depth of image analysis, reduces manual operations, and enhances the ability to extract useful information from images. A single-dimensional summary and overall summary SubAgent are used to hierarchically compress the analysis results of each chart, making the analysis results more concise, reliable, and reusable. Attached Figure Description

[0019] To more clearly illustrate the technical solutions in the embodiments of this application, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0020] Other features, objects, and advantages of this application will become more apparent from the following detailed description of non-limiting embodiments with reference to the accompanying drawings:

[0021] Figure 1 A flowchart for performing an analysis task according to an embodiment of this application is shown;

[0022] Figure 2 A flowchart of an exemplary system for analyzing a software environment according to an embodiment of this application is shown;

[0023] Figure 3 A schematic diagram of a device for performing an analysis task according to an embodiment of this application is shown;

[0024] Figure 4 A schematic diagram of the structure of a device suitable for implementing the scheme in the embodiments of this application is shown.

[0025] The same or similar reference numerals in the accompanying drawings represent the same or similar parts. Detailed Implementation

[0026] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0027] In a typical configuration of this application, the terminal and the service network devices each include one or more processors (CPUs), input / output interfaces, network interfaces, and memory.

[0028] 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.

[0029] Computer-readable media include permanent and non-permanent, removable and non-removable media, which can store information by any method or technology. Information can be computer program instructions, data structures, program modules, 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, read-only optical disc (CD-ROM), digital versatile optical disc (DVD) or other optical storage, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other non-transfer medium that can be used to store information accessible by a computing device.

[0030] Figure 1 A flowchart for performing an analysis task according to an embodiment of this application is shown. The method includes at least steps S101, S102, S103, and S104.

[0031] In practical scenarios, the execution entity of the method can be a computer device or an application running on a computer device. The computer device includes user devices or network devices. User devices include, but are not limited to, various terminal devices such as computers, mobile phones, tablets, smartwatches, and smart bands. Network devices include, but are not limited to, network hosts, single network servers, multiple network server sets, or cloud computing-based computer sets. Here, the cloud consists of a large number of hosts or network servers based on cloud computing, where cloud computing is a type of distributed computing, a virtual computer composed of a loosely coupled set of computers.

[0032] The terminology used in the embodiments of this application will be explained below.

[0033] SubAgent: In a large-scale multi-tool collaborative framework, it is an agent module responsible for independent sub-tasks. Each sub-module has its own independent context and executes a specific process.

[0034] Skill: Modules that provide domain-specific tool capabilities for large models, including information retrieval, command entry, image acquisition, report output, etc.

[0035] LLM: Large Language Model, a pre-trained language model based on the Transformer architecture, possessing powerful natural language understanding and generation capabilities.

[0036] It should be noted that all monitoring data acquired in this application was conducted in a private corporate network environment, and does not involve any personal privacy information or sensitive user data. Furthermore, the image acquisition process has been anonymized.

[0037] The following reference Figure 1 To explain, in step S101, in response to triggering the target analysis task, task requirement information is obtained and a target file is generated based on the task requirement information.

[0038] The target analysis task can include various types of analysis tasks, such as software operating environment analysis, performance evaluation, and fault diagnosis.

[0039] The task requirements information may include various details used to determine the specific object and time range of the data for the analysis task. For example, the server application identifier entered by the user can be used to identify the specific application to be analyzed, while the time period entered by the user limits the time range of the analysis.

[0040] Optionally, a target analysis task is triggered upon receiving an analysis task command input by the user. The analysis task command includes information indicating the server application identifier, time period, metric type, analysis dimension, etc., input by the user.

[0041] Optionally, target analysis tasks can be triggered based on preset monitoring strategies. For example, when the monitoring system detects that the performance indicators of the server application exceed preset thresholds, or when specific error codes appear in the system logs, a target analysis task is automatically triggered to conduct in-depth analysis and diagnosis of related issues.

[0042] The target file includes, but is not limited to, the following information:

[0043] 1) A detailed description of the analysis task; including the purpose of the task, expected outputs, and any specific analysis requirements; clearly define the purpose of the analysis, such as performance evaluation, fault diagnosis, or capacity planning. This helps guide subsequent analysis work and ensures that all analysis activities are centered around the established goals.

[0044] 2) User input parameters; User input parameters include server application identifier and time period, which can be used to determine the specific object and time range of the analysis;

[0045] 3) Expected analysis result format; used to indicate how the analysis results should be presented, such as reports, charts, data files, etc., so that users can understand and use them;

[0046] 4) Analytical tools and methods; including the specific tools and techniques used to perform the analysis, such as statistical analysis, machine learning models, data mining algorithms, etc.

[0047] Optionally, the target file also includes priorities. This helps to allocate analysis resources rationally when resources are limited, ensuring that critical tasks are given priority.

[0048] According to one embodiment, step S101 includes: obtaining task requirement information by parsing and analyzing task commands; then, converting the obtained task requirement information into an object file and storing it.

[0049] Specifically, first, an empty target file is created, which includes several predefined content items. This empty target file will serve as a container for storing all information related to the analysis tasks. The file format can be text, JSON, XML, etc., depending on the system implementation and requirements.

[0050] Next, information matching the multiple content items is extracted from the task requirement information and added to the target file, thereby converting the task requirement information into a target file and storing it.

[0051] Optionally, the created target file can be populated step by step based on the server application identifier and time period input by the user, as well as other possible inputs (such as analysis purpose, method, etc.).

[0052] The specific steps for populating the created target file may include: Adding a server-side application identifier: Adding the user-inputted application identifier to the file to specify the target application for analysis. Adding a time period: Adding the user-specified time period to the file to limit the analysis time range. Defining the analysis purpose: Adding the analysis purpose, such as performance evaluation or fault diagnosis, based on user input or system presets. Selecting an analysis method: Selecting appropriate analysis tools and methods based on the analysis purpose and system capabilities, and recording them in the file. Specifying the output format: Defining the output format of the analysis results, such as reports or charts, and adding them to the file.

[0053] Optionally, the generated target files will be stored in a specified working directory, thereby facilitating access to and use of this information and improving the efficiency and quality of the analysis.

[0054] In step 102, the analysis planning module is invoked to generate an analysis planning file based on the target file. The analysis planning file contains analysis planning files for multiple task nodes, and each task node corresponds to an independent task execution module.

[0055] The task node is a basic component of the analysis planning file, used to describe an independent analysis task and its execution parameters.

[0056] Optionally, the method pre-classifies task nodes and configures corresponding task execution modules for different types of task nodes.

[0057] According to one embodiment, the method further includes step S105 before step S101.

[0058] In step S105, multiple subtask agent modules corresponding to different types of task nodes are set up, so that each subtask agent module is used to handle the corresponding type of analysis task.

[0059] The types of task nodes are categorized based on the nature of the analysis task. For example, they can be classified according to the data type being processed, such as text analysis, image analysis, and numerical analysis. Alternatively, they can be classified according to the objective or application scenario of the analysis task, such as performance monitoring, fault diagnosis, and security auditing.

[0060] In this embodiment of the application, the subtask agent module can be represented as a SubAgent. Each SubAgent has an independent context and executes a specific task flow.

[0061] Optionally, the method in this application embodiment sets up an analysis planning SubAgent, a chart analysis SubAgent, a single-dimensional summary SubAgent, and an analysis report SubAgent. The analysis planning SubAgent is used to generate an analysis planning file; the chart analysis SubAgent is used to read task node content, parse the chart name, dimension, monitoring URL, and analysis criteria, call the image acquisition module to download monitoring images, and use the large model image understanding module for analysis to generate structured analysis results; the single-dimensional summary SubAgent is used to determine the corresponding dimension based on the task node content, read all chart analysis result files under that dimension, compress and summarize them, and generate a single-dimensional summary file; the analysis report SubAgent is used to read all dimension summary result files and perform an overall summary to generate a complete operational status report text.

[0062] According to one embodiment, the method sets up a sub-task agent module for analysis planning, that is, the analysis planning module is an analysis planning SubAgent.

[0063] The method calls the Analysis Planning SubAgent to perform the following steps S1021 to S1023 to generate the analysis planning file.

[0064] In step S1021, the key information required to generate the analysis planning document is obtained.

[0065] Optionally, the key information includes monitoring panel information and work target files. The monitoring panel information includes, but is not limited to, a list of available panels, URL concatenation rules, analysis criteria, and the corresponding dimensions, all of which are key elements for generating an effective analysis plan.

[0066] Optionally, the key information may also include relevant domain knowledge.

[0067] Optionally, monitoring panel information or domain knowledge can be obtained through skill modules. These skill modules provide the large model with domain-specific tool capabilities, including information retrieval, command entry, image acquisition, and report output. A skill is a software component containing prompts and corresponding script code. When the prompt is used, it guides the large model to call the script code within the module to perform a specific function.

[0068] For example, in step S1021, relevant domain knowledge skills are read to provide additional background information and best practices for the analysis, and monitoring panel skills are read, including information such as the list of available panels, URL concatenation rules, analysis criteria, and the corresponding dimensions. Next, the working target file is read.

[0069] In step S1022, based on the key information, an analysis planning file containing multiple task nodes is generated according to the planning template. For example, when generating a chart analysis task, SubAgent will fill in the complete monitoring URL to ensure direct access to the required data.

[0070] In step S1023, the generated analysis planning file is stored, and the storage path of the file is output so that it can be accessed and used later.

[0071] According to one embodiment, in step S102, an analysis planning file containing multiple task nodes is generated using a predefined set of analysis templates based on the application type. In this approach, the SubAgent selects a suitable predefined template based on the specific type of application. These templates are customized for specific application scenarios and can quickly generate applicable analysis plans. This method is suitable for application scenarios with clear analysis needs and standard processes.

[0072] In step S103, for each of the multiple task nodes in the analysis planning file, the corresponding task execution module is called to execute the analysis task and generate and store the analysis results.

[0073] Optionally, the analysis results generated by each task execution module are written to disk to form a context file. The context file in this embodiment is a text file that stores readable information for the current step, used to avoid overloading the context of a large model in long workflows.

[0074] According to one embodiment, the method sets up a sub-task agent module (image analysis SubAgent) for image analysis. In step S103, at the task node corresponding to image analysis, the method calls the image analysis SubAgent to obtain target image data, and analyzes the image through the large model image understanding module to generate structured analysis results.

[0075] Specifically, the method calls the image analysis SubAgent to perform the following steps S1031 to S1033.

[0076] In step S1031, node task information is obtained. This task node information includes, but is not limited to, task node content, parsed chart name, associated dimension, URL, and analysis criteria. The parsed chart name specifies the specific data chart to be analyzed, the associated dimension defines the scope or perspective of the analysis, such as by time, geographic location, or service type. The URL provides the network address for obtaining the relevant data, and the analysis criteria include specific guidelines or thresholds for evaluating the data and identifying problems.

[0077] Optionally, domain knowledge skills can be retrieved. Specifically, domain knowledge skills relevant to the current analysis task can be loaded, which may include the expertise and rules of experience required to perform the analysis. Domain knowledge skills may include knowledge of a specific application or service, historical data analysis results, industry standards, and best practices.

[0078] In step S1032, the target image data to be analyzed is obtained.

[0079] Optionally, the corresponding monitoring image can be acquired using an automated image acquisition component as the target image data. The automated image acquisition component includes a headless browser, and the method obtains the corresponding monitoring image by taking screenshots and downloading them using the headless browser. For example, an image acquisition skill can be invoked to acquire the corresponding monitoring image using the automated image acquisition component.

[0080] Optionally, images can be obtained using the API provided by the monitoring platform, or PNG or SVG format charts can be obtained using a URL rendering service as the target image data. This implementation provides a variety of alternative methods to offer more flexible or efficient image acquisition methods.

[0081] In step S1033, the target image data is analyzed using a large model to generate structured analysis results and store them.

[0082] Optionally, the image analysis SubAgent saves the generated analysis results and outputs the storage path.

[0083] Specifically, the process of using a large model to analyze target image data and generate structured analysis results includes:

[0084] The target image data is preprocessed to ensure image quality suitable for depth analysis. Preprocessing may include image resizing, cropping, rotation correction, grayscale conversion, and denoising. The preprocessed image is then fed into a large model, which utilizes its deep learning capabilities to extract key features from the image, such as edges, textures, color distribution, shapes, and object contours. These features are fundamental to image recognition and classification.

[0085] Next, the large model performs semantic understanding by identifying and classifying patterns in the image, associating identified objects, scenes, or behaviors with known categories or labels. This step transforms elements in the image into understandable information and interprets the meaning of these elements in a specific context. The large model then transforms these analysis results into structured data, such as JSON, XML, or database records, containing the identified objects in the image along with their location, size, attributes, and any relevant semantic information.

[0086] Optionally, to ensure the accuracy of the analysis results, the generated structured results may be validated and optimized. This could involve comparison with known data, integration of user feedback, or further model training. Once validated, the analysis results will be output to a specified storage location, such as a file system, database, or provided to other systems via API for report generation, further data analysis, or as input for other business processes.

[0087] Optionally, to help users better understand and interpret the analysis results, the structured analysis results can be converted into visual charts or graphs, enabling users to intuitively understand the image content and analysis results.

[0088] Through the above methods, the large model image understanding of this application embodiment can not only identify elements in the image, but also provide in-depth insights into the image content, providing a powerful analysis tool for various application scenarios.

[0089] According to one example, in a complex RPC end-to-end fault diagnosis scenario, multiple sub-task agent modules (SubAgent) work together to complete the entire process analysis from fault detection to fault location.

[0090] First, the fault detection SubAgent is responsible for monitoring the specified services and interfaces. Specifically, it receives a task instruction that includes information such as the service name, interface path, monitoring time range, and performance thresholds. Upon detecting an anomaly, the fault detection subAgent generates a fault flag and passes the relevant information to the fault location subAgent in the next stage.

[0091] Next, the fault location sub-agent begins analysis based on information provided by the fault detection sub-agent, such as the service, interface, and specific time of the fault, as well as a list of other services that the service depends on. Specifically, it first obtains the full-chain call information at the time of the fault through a distributed tracing system to understand the call order, response time, and error information between services. Then, it analyzes the upstream and downstream dependencies of the services to determine if the fault was caused by a downstream service. For example, if the order service times out when calling the payment service, the payment service may be the source of the fault. Furthermore, it combines log information from each service to further confirm the root cause of the fault, such as database query failures or network latency. Finally, the fault location sub-agent organizes the fault location results into structured data and generates a detailed fault report, including information such as the fault location, possible causes, and scope of impact, so that operations personnel can quickly understand the problem and take appropriate measures.

[0092] In the fault localization phase, a pre-trained large model is used for analysis. The core of this large model analysis is guiding the model's operation through a Prompt. For example, a Prompt might contain the following:

[0093] The service and interface where the failure occurred: clearly identify the failure point that needs to be analyzed.

[0094] Time range: Specifies the specific time window in which the fault occurs.

[0095] Related dependent services: List other services that have direct dependencies on the faulty service.

[0096] Analysis objective: To clearly require the model to output the root cause of the failure, the scope of its impact, and possible solutions.

[0097] Based on the information in the Prompt, the large model extracts key features from call chain data and logs, identifies anomaly patterns, and analyzes the causal relationships between these anomalies. Ultimately, the model generates structured analysis results, including fault location, possible causes, and impact scope. These results will be compiled into detailed fault reports for operations and maintenance personnel to reference.

[0098] By using the Prompt-guided model analysis, this example can efficiently handle complex RPC end-to-end failures, providing accurate fault location and detailed analysis reports, thereby helping operations and maintenance personnel quickly resolve problems and improve system reliability and stability.

[0099] Alternatively, in addition to using a large model, embodiments of this application can also obtain analysis results by converting charts into data points and then performing structured analysis, or by combining numerical analysis models to assist in judgment. Converting charts into data points for structured analysis allows for more direct extraction of useful information from the charts. Combining numerical analysis models to assist in judgment helps improve the accuracy and reliability of the analysis.

[0100] In step S104, based on the analysis results obtained from each task execution module, an analysis report file for the target analysis task is generated.

[0101] According to one embodiment, step S104 includes: summarizing the structured analysis results of each task node in a single dimension to generate a single-dimensional summary file; then, by summarizing all the single-dimensional summary files, generating a multi-dimensional analysis report file.

[0102] According to one embodiment, in step S104, the single-dimensional summary SubAgent and the analysis report SubAgent are invoked. Specifically, the single-dimensional summary SubAgent reads the domain knowledge Skill (if available), and then determines the corresponding dimension based on the task node content. Next, the single-dimensional summary SubAgent reads all chart analysis result files under that dimension and compresses and summarizes the results to generate a concise single-dimensional summary file. Finally, the single-dimensional summary SubAgent saves this summary file and outputs its path for access.

[0103] After completing all single-dimensional summaries, the Analysis Report SubAgent is invoked to execute operations. Similarly, the Analysis Report SubAgent can also read the domain knowledge Skill, then read the summary result files for all dimensions, and perform an overall summary. After completing the overall summary, the Analysis Report SubAgent saves the overall report text and outputs the path, allowing the generated report file to be sent or further processed.

[0104] For example, the content of a single-dimensional analysis report may look like this:

[0105] Target Indicators

[0106] Metric Name: CPU Utilization - Instance-independent

[0107] Metric meaning: Overall CPU utilization of all instances at the container level.

[0108] Time range: 2025-11-26 19:33:00 to 20:33:00 (UTC time)

[0109] in conclusion

[0110] Problem level: Normal

[0111] Analysis content:

[0112] The CPU utilization of all three clusters remained around 4%, well below the normal threshold of 40%.

[0113] The CPU utilization curves of each cluster are stable with no significant fluctuations.

[0114] Optimization suggestions:

[0115] No optimization required, CPU resource utilization is healthy.

[0116] Attached Figure

[0117] A screenshot of the CPU usage monitoring chart is provided.

[0118] In this exemplary single-dimensional analysis report, the target metric section details the metric name (dimension, CPU utilization in this example), its meaning and time range, the overall CPU utilization of all instances at the container level, and the specific time range of the analysis. The conclusion section provides the issue level based on the analysis, such as "normal," and provides detailed analysis results, such as the CPU utilization of all three clusters remaining around 4%, far below the normal threshold of 40%, and the CPU utilization curves of each cluster being stable without significant fluctuations. Furthermore, optimization suggestions are given, such as "no optimization required, CPU resource utilization is healthy." The attached chart provides screenshots of the CPU utilization monitoring graphs to visually demonstrate the analysis results.

[0119] It should be noted that this application addresses the context window limitation problem through the following mechanisms: First, the complete analysis process is broken down into multiple independent SubAgents. Each SubAgent only handles the task of its current stage and does not need to be aware of all historical information in the entire analysis chain. Second, text content is not directly passed between SubAgents; instead, the output of each SubAgent is written to disk to form a context file. Subsequent SubAgents only receive file paths related to their tasks and read file content as needed during execution. Finally, during the main process scheduling, only the content of the current task node and the necessary file paths are provided to the SubAgents, avoiding the concatenation of all previous analysis results into the same model call, thereby significantly reducing the context length of a single call. Through the above design, stable execution of multi-step analysis processes can be achieved without relying on expanding the model context window. This method not only improves the efficiency of analysis but also ensures the accuracy and reliability of the analysis.

[0120] According to one embodiment, the generated analysis report file is pushed to the terminal where the target object is located.

[0121] The target objects include, but are not limited to, users or systems that receive and view the analysis reports. Examples include operations engineers, R&D team leaders, automated operations platforms, or third-party monitoring systems.

[0122] Optionally, analysis report files can be pushed via Webhook.

[0123] Alternatively, in addition to push notifications via webhooks, analytics results can also be delivered through email systems, internal message queues, enterprise notification systems, and other means. These multiple alternative report delivery methods provide users with flexibility, allowing them to receive and view analytics reports in a way that suits their preferences.

[0124] According to the method of this application embodiment, the entire analysis task is divided into multiple sub-tasks, each executed by an independent module and stored in a file, effectively solving the problem of context overload in long-running large models, thereby improving the stability and reliability of the entire system. A sub-task proxy module for analysis planning is introduced, which automatically generates analysis planning files containing all nodes through a template-based approach, achieving structured and reusable analysis tasks and improving the efficiency and accuracy of task planning. Deep analysis of images using a large model enhances the automation level and depth of image analysis, reduces manual operations, and improves the ability to extract useful information from images. The sub-task proxy module for single-dimensional and overall summarization compresses the analysis results of each chart hierarchically, making the analysis results more concise, reliable, and reusable.

[0125] The following example will illustrate this point.

[0126] This example provides a system for analyzing the software runtime environment. The system architecture consists of multiple SubAgents, multiple Skill modules, and a file storage module. The main flow control Skill manages the entire process; the monitoring panel Skill provides monitoring URLs, analysis criteria, and dimensions; the image acquisition Skill provides automatic screenshot capabilities; the analysis planning SubAgent is responsible for generating the plan; the chart analysis, single-dimensional summary, and analysis report SubAgents handle different stages of the analysis; and the file system is used to store context files and analysis results.

[0127] Reference Figure 2 The main workflow of this system is as follows:

[0128] Users input the server application identifier and time period in the interface, and the system receives this information as input for the analysis task.

[0129] The system writes the received user input to a working target file on the disk;

[0130] The system invokes the analysis and planning SubAgent to generate an analysis and planning file based on user input. If the generation of the analysis and planning file fails, the system will log the error and terminate the process.

[0131] After successfully generating the analysis planning file, the system reads the file to understand the specific requirements of the analysis task.

[0132] The system checks if all task nodes have been completed. If any nodes are incomplete, the system will proceed to execute the next task node.

[0133] Depending on the type of task node, the system invokes the corresponding SubAgent to handle the specific analysis task:

[0134] If the node type is chart analysis, the system will invoke the chart analysis sub-Agent. This sub-Agent uses the image acquisition skill to download the monitoring image, then uses large model image understanding to analyze the image, and saves the analysis results to disk. If the node type is single-dimensional summary, the system will invoke the single-dimensional summary sub-Agent. This sub-Agent reads all chart analysis result files under that dimension, compresses and summarizes them, and saves them. If the node type is analysis report, the system will invoke the analysis report sub-Agent. This sub-Agent reads the summary results of all dimensions, generates the final analysis report, and saves it.

[0135] In the monitoring dashboard example, the system can handle monitoring data from multiple dimensions. For instance, the HTTP dimension includes service HTTP availability, error rate, and latency; the RPC dimension includes RPC success rate, latency, and failure rate; the container dimension involves CPU utilization, memory utilization, and Pod restart count; and the runtime dimension focuses on garbage collection time. These dimensions can be extended to other dimensions such as databases, caches, and message queues.

[0136] For monitoring metric analysis standards, default standards can be used for general metrics such as CPU and memory. For business-related metrics, custom analysis standards can be defined within the monitoring panel's Skill. When an analysis node is executed, it will read the corresponding standard to determine the status of that metric.

[0137] After all nodes have completed their execution, the system reads the final analysis report file.

[0138] The system calls a report output skill, which automatically sends the generated analysis report to the user's chat software via a webhook.

[0139] The process described above in this example improves the user experience, making monitoring and analysis a one-time triggered, automated process that requires no manual intervention from the user at each step.

[0140] Figure 3 A schematic diagram of an apparatus for performing an analysis task according to an embodiment of this application is shown. The apparatus includes a document generation module 101, a planning generation module 102, a task execution module 103, and a report generation module 104.

[0141] In response to triggering the target analysis task, the file generation module 101 obtains task requirement information and generates a target file based on the task requirement information.

[0142] The target analysis task, task requirements information, and target files have been described in the preceding text and will not be repeated here.

[0143] Optionally, a target analysis task is triggered upon receiving an analysis task command input by the user. The analysis task command includes information indicating the server application identifier, time period, metric type, analysis dimension, etc., input by the user.

[0144] Optionally, target analysis tasks can be triggered based on preset monitoring strategies. For example, when the monitoring system detects that the performance indicators of the server application exceed preset thresholds, or when specific error codes appear in the system logs, a target analysis task is automatically triggered to conduct in-depth analysis and diagnosis of related issues.

[0145] According to one embodiment, the file generation module 101 obtains task requirement information by parsing and analyzing task commands. Then, the obtained task requirement information is converted into a target file and stored.

[0146] Specifically, first, an empty target file is created, which includes multiple predefined content items. Then, information matching these content items is extracted from the task requirement information and added to the target file, thereby transforming the task requirement information into a target file and storing it.

[0147] Optionally, the created target file is populated progressively based on the server application identifier and time period input by the user, as well as other possible inputs (such as analysis purpose, method, etc.). The process of populating the created target file has been described above and will not be repeated here.

[0148] Continue to refer to Figure 3 To explain, the planning generation module 102 calls the analysis planning module to generate an analysis planning file based on the target file. The analysis planning file contains analysis planning files for multiple task nodes, and each task node corresponds to an independent task execution module.

[0149] The task node is a basic component of the analysis planning file, used to describe an independent analysis task and its execution parameters.

[0150] Optionally, the device pre-classifies task nodes and configures corresponding task execution modules for different types of task nodes.

[0151] According to one embodiment, the device further includes a subtask configuration module.

[0152] In the subtask configuration module, multiple subtask agent modules corresponding to different types of task nodes are set up so that each subtask agent module can handle the corresponding type of analysis task.

[0153] The types of task nodes are categorized based on the nature of the analysis task. For example, they can be classified according to the data type being processed, such as text analysis, image analysis, and numerical analysis. Alternatively, they can be classified according to the objective or application scenario of the analysis task, such as performance monitoring, fault diagnosis, and security auditing.

[0154] The subtask agent module in this embodiment can be represented as a SubAgent. Each SubAgent has an independent context and executes a specific task flow.

[0155] According to one embodiment, the subtask configuration module sets up a subtask agent module for analysis planning, that is, the analysis planning module is an analysis planning SubAgent.

[0156] Optionally, the method in this application embodiment sets up an analysis planning SubAgent, a chart analysis SubAgent, a single-dimensional summary SubAgent, and an analysis report SubAgent. The analysis planning SubAgent is used to generate an analysis planning file; the chart analysis SubAgent is used to read task node content, parse the chart name, dimension, monitoring URL, and analysis criteria, call the image acquisition module to download monitoring images, and use the large model image understanding module for analysis to generate structured analysis results; the single-dimensional summary SubAgent is used to determine the corresponding dimension based on the task node content, read all chart analysis result files under that dimension, compress and summarize them, and generate a single-dimensional summary file; the analysis report SubAgent is used to read all dimension summary result files and perform an overall summary to generate a complete operational status report text.

[0157] According to one embodiment, the planning generation module 102 calls the analysis planning SubAgent to perform the following operations to generate an analysis planning file.

[0158] Obtain the key information required to generate the analysis planning document. Optionally, the key information includes monitoring panel information and working target files. The monitoring panel information includes, but is not limited to, a list of available panels, URL concatenation rules, analysis criteria, and the corresponding dimensions; these are key elements for generating an effective analysis plan. Optionally, the key information also includes relevant domain knowledge. Optionally, monitoring panel information or domain knowledge can be obtained through skill modules. The skill modules are modules that provide domain-specific tool capabilities for large models, including information retrieval, command entry, image acquisition, and report output.

[0159] Next, based on the key information, an analysis and planning document containing multiple task nodes is generated according to the planning template.

[0160] Next, the generated analysis planning file is stored, and the file's storage path is output for later access and use.

[0161] According to one embodiment, the planning generation module 102 generates an analysis planning file containing multiple task nodes using a predefined set of analysis templates based on the application type. In this approach, the SubAgent selects a suitable predefined template based on the specific type of application. These templates are customized for specific application scenarios and can quickly generate applicable analysis plans. This method is suitable for application scenarios with clear analysis needs and standard processes.

[0162] Continue to refer to Figure 3 To explain, the task execution module 103 calls the corresponding task execution module for each of the multiple task nodes in the analysis planning file to execute the analysis task and generate and store the analysis results.

[0163] Optionally, the analysis results generated by each task execution module are written to disk to form a context file. The context file in this embodiment is a text file that stores readable information for the current step, used to avoid overloading the context of a large model in long workflows.

[0164] According to one embodiment, the method sets up a sub-task agent module (image analysis SubAgent) for image analysis. The task execution module 103 calls the image analysis SubAgent to obtain target image data at the task node corresponding to the image analysis, and analyzes the image through the large model image understanding module to generate structured analysis results.

[0165] Specifically, the method invokes the image analysis SubAgent to perform the following operations:

[0166] Obtain node task information. This task node information includes, but is not limited to, task node content, parsed chart name, associated dimension, URL, and analysis criteria. The parsed chart name specifies the specific data chart to be analyzed, the associated dimension defines the scope or perspective of the analysis, such as by time, geographic location, or service type. The URL provides the network address for obtaining the relevant data, and the analysis criteria contain specific guidelines or thresholds for evaluating the data and identifying problems. Optionally, read domain knowledge skills. Specifically, load domain knowledge skills related to the current analysis task, which may include the professional knowledge and rules of experience required to perform the analysis. Domain knowledge skills may include understanding of specific applications or services, historical data analysis results, industry standards, and best practices.

[0167] Next, the target image data to be analyzed is acquired. Optionally, the corresponding monitoring image is acquired through an automated image acquisition component as the target image data. The automated image acquisition component includes a headless browser, and the method obtains the corresponding monitoring image by taking a screenshot and downloading it through the headless browser. For example, an image acquisition skill can be called to acquire the corresponding monitoring image through the automated image acquisition component. Optionally, the image can be acquired using the API provided by the monitoring platform, or a URL rendering service can be used to obtain PNG or SVG format charts as target image data. This implementation provides multiple alternative methods to offer a more flexible or efficient image acquisition approach.

[0168] Next, the target image data is analyzed using a large model to generate structured analysis results and store them. Optionally, the image analysis SubAgent saves the generated analysis results and outputs the storage path.

[0169] Specifically, the process of using a large model to analyze target image data and generate structured analysis results has been described above and will not be repeated here.

[0170] Optionally, to ensure the accuracy of the analysis results, the generated structured results may be validated and optimized. This could involve comparison with known data, integration of user feedback, or further model training. Once validated, the analysis results will be output to a specified storage location, such as a file system, database, or provided to other systems via API for report generation, further data analysis, or as input for other business processes.

[0171] Optionally, to help users better understand and interpret the analysis results, the structured analysis results can be converted into visual charts or graphs, enabling users to intuitively understand the image content and analysis results.

[0172] Through the above methods, the large model image understanding of this application embodiment can not only identify elements in the image, but also provide in-depth insights into the image content, providing a powerful analysis tool for various application scenarios.

[0173] The report generation module 104 generates an analysis report file for the target analysis task based on the analysis results obtained from each task execution module.

[0174] According to one embodiment, the report generation module 104 performs a one-dimensional summary of the structured analysis results of each task node and generates a one-dimensional summary file; then, by summarizing all the one-dimensional summary files, a multi-dimensional analysis report file is generated.

[0175] According to one embodiment, in step S104, the single-dimensional summary SubAgent and the analysis report SubAgent are invoked. Specifically, the single-dimensional summary SubAgent reads the domain knowledge Skill (if available), and then determines the corresponding dimension based on the task node content. Next, the single-dimensional summary SubAgent reads all chart analysis result files under that dimension and compresses and summarizes the results to generate a concise single-dimensional summary file. Finally, the single-dimensional summary SubAgent saves this summary file and outputs its path for access.

[0176] After completing all single-dimensional summaries, the Analysis Report SubAgent is invoked to execute operations. Similarly, the Analysis Report SubAgent can also read the domain knowledge Skill, then read the summary result files for all dimensions, and perform an overall summary. After completing the overall summary, the Analysis Report SubAgent saves the overall report text and outputs the path, allowing the generated report file to be sent or further processed.

[0177] According to one embodiment, the generated analysis report file is pushed to the terminal where the target object is located.

[0178] The target objects include, but are not limited to, users or systems that receive and view the analysis reports. Examples include operations engineers, R&D team leaders, automated operations platforms, or third-party monitoring systems.

[0179] Optionally, analysis report files can be pushed via Webhook.

[0180] Alternatively, in addition to push notifications via webhooks, analytics results can also be delivered through email systems, internal message queues, enterprise notification systems, and other means. These multiple alternative report delivery methods provide users with flexibility, allowing them to receive and view analytics reports in a way that suits their preferences.

[0181] The apparatus according to the embodiments of this application breaks down the entire analysis task into multiple sub-tasks, each executed by an independent module and stored in a file, effectively solving the problem of context overload in long-running large models, thereby improving the stability and reliability of the entire system. A sub-task proxy module for analysis planning is introduced, which automatically generates analysis planning files containing all nodes through a template-based approach, achieving structured and reusable analysis tasks and improving the efficiency and accuracy of task planning. Deep analysis of images using a large model enhances the automation level and depth of image analysis, reduces manual operations, and improves the ability to extract useful information from images. The sub-task proxy module for single-dimensional and overall summarization compresses the analysis results of each chart hierarchically, making the analysis results more concise, reliable, and reusable.

[0182] Based on the same inventive concept, this application also provides an electronic device. The method corresponding to the electronic device can be the method in the foregoing embodiments, and its problem-solving principle is similar to that method. The electronic device provided in this application includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to execute the methods and / or technical solutions of the foregoing embodiments of this application.

[0183] The electronic device can be a user device, or a device formed by integrating user devices and network devices through a network, or it can be an application running on the aforementioned devices. The user device includes, but is not limited to, various terminal devices such as computers, mobile phones, tablets, smartwatches, and wristbands. The network device includes, but is not limited to, network hosts, single network servers, multiple network server sets, or cloud computing-based computer sets, and can be used to implement some processing functions when setting an alarm clock. Here, the cloud consists of a large number of hosts or network servers based on cloud computing. Cloud computing is a type of distributed computing, consisting of a virtual computer composed of a group of loosely coupled computer sets.

[0184] Figure 4The diagram illustrates the structure of an apparatus suitable for implementing the methods and / or technical solutions in the embodiments of this application. The apparatus 1200 includes a Central Processing Unit (CPU) 1201, which can perform various appropriate actions and processes based on a program stored in a Read Only Memory (ROM) 1202 or a program loaded from a storage portion 1208 into a Random Access Memory (RAM) 1203. The RAM 1203 also stores various programs and data required for system operation. The CPU 1201, ROM 1202, and RAM 1203 are interconnected via a bus 1204. An Input / Output (I / O) interface 1205 is also connected to the bus 1204.

[0185] The following components are connected to I / O interface 1205: an input section 1206 including a keyboard, mouse, touchscreen, microphone, infrared sensor, etc.; an output section 1207 including a cathode ray tube (CRT), liquid crystal display (LCD), LED display, OLED display, etc., and speakers, etc.; a storage section 1208 including one or more computer-readable media such as hard disk, optical disk, magnetic disk, semiconductor memory, etc.; and a communication section 1209 including a network interface card such as a LAN (Local Area Network) card, modem, etc. The communication section 1209 performs communication processing via a network such as the Internet.

[0186] In particular, the methods and / or embodiments in this application can be implemented as computer software programs. For example, the embodiments disclosed in this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowchart. When the computer program is executed by the central processing unit (CPU) 1201, it performs the functions defined in the methods of this application.

[0187] Another embodiment of this application provides a computer-readable storage medium having computer program instructions stored thereon, which can be executed by a processor to implement the methods and / or technical solutions of any one or more embodiments of this application described above.

[0188] Specifically, this embodiment may employ any combination of one or more computer-readable media. A computer-readable medium may be a computer-readable signal medium or a computer-readable storage medium. A computer-readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of computer-readable storage media (a non-exhaustive list) include: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In this document, a computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device.

[0189] Computer-readable signal media may include data signals propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such propagated data signals may take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. Computer-readable signal media may also be any computer-readable medium other than computer-readable storage media, capable of sending, propagating, or transmitting programs for use by or in connection with an instruction execution system, apparatus, or device.

[0190] Program code contained on a computer-readable medium may be transmitted using any suitable medium, including but not limited to wireless, wire, optical fiber, RF, etc., or any suitable combination thereof.

[0191] The program code can execute entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0192] The flowcharts or block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of devices, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-specific system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0193] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0194] In the several embodiments provided in this application, it should be understood that the disclosed systems, apparatuses, and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or page components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be an indirect coupling or communication connection between devices or units through some interfaces, and may be electrical, mechanical, or other forms.

[0195] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0196] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or in a combination of hardware and software functional units.

[0197] The integrated units implemented as software functional units described above can be stored in a computer-readable storage medium. These software functional units, stored in a storage medium, include several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) or processor to execute some steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0198] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application.

[0199] Furthermore, it is clear that the word "comprising" does not exclude other units or steps, and the singular does not exclude the plural. Multiple units or devices described in an apparatus may also be implemented by a single unit or device through software or hardware. Terms such as "first," "second," etc., are used to indicate names and do not indicate any specific order.

Claims

1. A method for performing an analysis task, wherein, The method includes: In response to triggering a target analysis task, task requirement information is obtained and a target file is generated based on the task requirement information; The analysis planning module is invoked to generate an analysis planning file based on the target file. The analysis planning file contains multiple task nodes, and each task node corresponds to an independent task execution module. For multiple task nodes in the analysis planning document, the corresponding task execution module is called for each node to execute the analysis task and generate and store the analysis results; Based on the analysis results obtained from each task execution module, an analysis report file for the target analysis task is generated.

2. The method according to claim 1, wherein, The method further includes: Multiple subtask agent modules are set up to correspond to different types of task nodes, so that each subtask agent module is used to handle the corresponding type of analysis task. The types of task nodes are divided according to the nature of the analysis task.

3. The method according to claim 1 or 2, wherein, The method sets up a sub-task agent module for analysis planning, and the method calls the sub-task agent module for analysis planning to perform the following steps to generate an analysis planning file: Obtain the key information needed to generate the analysis and planning documents; Based on the key information, an analysis and planning document containing multiple task nodes is generated according to the planning template; Store the generated analysis planning file and output the file's storage path.

4. The method according to claim 1 or 2, wherein, The method sets up a sub-task proxy module for image analysis. At the task node corresponding to image analysis, the method calls the sub-task proxy module to perform the following steps: Obtain node task information; Acquire the target image data that needs to be analyzed; Large models are used to analyze target image data, generate structured analysis results, and store them.

5. The method according to claim 4, wherein, Obtaining the target image data to be analyzed includes: The corresponding monitoring images are acquired through automated image acquisition components and used as target image data.

6. The method according to claim 1, wherein, The generation of the analysis report file for the target analysis task based on the analysis results obtained from each task execution module includes: Summarize the structured analysis results of each task node in a single dimension and generate a single-dimensional summary file; By summarizing all the single-dimensional summary files, a multi-dimensional analysis report file is generated.

7. The method according to claim 1, wherein, Obtaining task requirement information and generating target files based on the task requirement information includes: By parsing and analyzing the task commands, we can obtain the task requirement information; The obtained task requirement information is converted into target files and stored.

8. The method according to claim 1 or 2, wherein, The method further includes: The generated analysis report file is pushed to the terminal where the target object is located.

9. An apparatus for performing an analysis task, wherein, The device includes: The file generation module is used to respond to the triggering of a target analysis task, obtain task requirement information, and generate a target file based on the task requirement information. The planning generation module is used to call the analysis planning module to generate an analysis planning file based on the target file. The analysis planning file contains multiple task nodes, and each task node corresponds to an independent task execution module. The node analysis module is used to call the corresponding task execution module for each of the multiple task nodes in the analysis planning file to execute the analysis task, and generate and store the analysis results. The report generation module is used to generate analysis report files for the target analysis task based on the analysis results obtained from each task execution module.

10. An electronic device, the electronic device comprising: At least one processor; as well as A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor to enable the at least one processor to perform the method of any one of claims 1 to 8.

11. A computer-readable medium having stored thereon computer program instructions that can be executed by a processor to implement the method as described in any one of claims 1 to 8.

12. A computer program product comprising a computer program that, when executed by a processor, implements the method as described in any one of claims 1 to 8.

Images