Microservice-based whole-process project visual management system and method

Abstract

The invention discloses a whole-process project visualization management system and method based on micro-service, and particularly relates to the field of project visualization, and the system comprises a micro-service registration center module, an event traceability bus module, a twin visualization engine module, a reverse control gateway module, and a whole-process project semantic knowledge graph module. According to the method, an instance is registered through a micro-service registration center in a dynamic grid topology mode, a heartbeat side vehicle is injected through an eBPF to collect a KPI quintuple, the health degree is judged through a risk tensor field, and semantic fusing and early warning are triggered; a rendering instruction is embedded in the event traceability bus, an event is persisted according to a three-level strategy, a twin visualization engine generates a scene through a biaxial pipeline, node coordinates and thermal textures are calculated through multiple formulas, a visual angle is predicted, and a risk focusing special effect is achieved; the whole-process semantic knowledge graph is subjected to semantic extraction and triple establishment, edge weights are jointly calculated, and abnormal root causes are embedded and positioned by means of the graph.

Description

Technical Field

[0001] This invention relates to the field of project visualization technology, and more specifically, to a microservice-based end-to-end project visualization management system and method. Background Technology

[0002] In the current wave of digital transformation, the management of complex projects in construction, manufacturing, and IT is facing unprecedented challenges. These projects typically have long cycles, numerous stakeholders, complex business processes, and involve massive amounts of multi-source heterogeneous data, such as design drawings, schedules, cost reports, and equipment sensor data. Traditional project management software often adopts a monolithic architecture, with tightly coupled system modules, poor scalability, and difficulty in adapting to the dynamic changes throughout the project lifecycle. More importantly, these systems usually display data in two-dimensional formats such as forms and charts, lacking an intuitive, three-dimensional, and real-time panoramic view of the project. This makes it difficult for managers to quickly identify potential risks and understand complex relationships, resulting in delayed decision-making and low efficiency.

[0003] The existing technology has the following main pain points: First, system monitoring is disconnected from business health. Traditional service heartbeats can only determine whether a process is alive, but cannot perceive whether the business it carries is running healthily. Second, data visualization is separated from business logic. Third, management actions are disconnected from visualization scenarios. After users discover an anomaly in the 3D scenario, they still need to switch to the traditional management interface to operate. They cannot directly implement control in the visualization environment, which interrupts the closed-loop management process of "what you see is what you control". Summary of the Invention

[0004] To overcome the aforementioned deficiencies of the prior art, embodiments of the present invention provide a microservice-based full-process project visualization management system and method to address the problems raised in the background section.

[0005] To achieve the above objectives, the present invention provides the following technical solution:

[0006] Microservice Registry Module: Used to register and perform health checks on several microservice instances in a dynamic service mesh topology. The health check includes a "business semantic level heartbeat" probe on the service instance, which carries a snapshot of the key performance indicators (KPIs) of the project stage currently being processed by the instance.

[0007] Event sourcing bus module: used to persist all domain events generated by microservices and embed a visual rendering instruction set in the event stream. The rendering instruction set is generated locally by the microservice that generated the event through the rendering strategy engine.

[0008] The twin visualization engine module is used to parse the rendering instruction set and generate a digital twin visualization scene in real time. The scene maps the microservice call chain and project stage milestones in a three-dimensional node-edge graph manner.

[0009] Reverse control gateway module: used to receive user interaction operations in the visualization scenario, and convert the operations into declarative governance commands for the microservice cluster. The governance commands are written back as compensation events through the event sourcing bus, triggering the process re-arrangement of the corresponding microservice instance.

[0010] The full-process project semantic knowledge graph module is used to extract semantics from the event stream and dynamically construct a project-task-microservice triple knowledge graph. The edge weights of the knowledge graph are calculated jointly by microservice call latency, critical path fluctuations in project phases, and resource costs, and are located through anomaly root cause localization based on graph embedding.

[0011] Preferably, in the microservice registry module, the registry intercepts the socket calls of each instance at the kernel layer through an eBPF probe during the startup phase, automatically injecting a lightweight "heartbeat sidecar" bytecode. This bytecode is activated after the instance's business thread completes any project phase state machine transition, and immediately collects the KPI five-tuple defined for the current phase, namely, the remaining project duration fluctuation ΔT, the budget burn rate ∇C, the requirement completion rate ρ, and the defect density. The pass rate η of the deliverables review is calculated and encapsulated into a Protocol-KPI data packet using a zero-copy memory method. Subsequently, Sidecar-Beat sends the data packet back to the registry center using a pre-negotiated QUIC encrypted link. Upon receiving the heartbeat, the registry center projects the KPI quintuple into the three-dimensional risk tensor field (ΔT, ∇C, ρ×σ×η) in real time, and dynamically calculates the health equivalent hyperplane distance of the instance in the current project stage through online kernel density estimation. ;like If the bandwidth exceeds the historical μ±2σ, the registry center immediately triggers a "semantic-level circuit breaker". On the one hand, it sends a traffic coloring instruction to the service mesh data plane to redirect subsequent requests to healthy neighbor instances proportionally. On the other hand, it writes the risk tensor coordinates into the event tracing bus, driving the twin visualization engine to render the instance node as the highest level visual alarm signal form, and simultaneously pushes it to the project manager's AR glasses, realizing a zero-manual closed loop of business semantic anomaly - registry center - visualization.

[0012] Preferably, in the event sourcing bus module, each domain event is intercepted by a built-in lightweight Renderlet thread when the business aggregation root submits a change. This thread runs in the same process as the business logic but is located in an independent Loom virtual thread. It dynamically selects a pluggable rendering strategy by reading the "rendering context token" in the local thread local storage (TLS), which contains an 18-dimensional context including the current project stage, user view coordinates, terminal device pixel density, and GPU memory availability. The strategy library is pre-installed in the startup container layer in the form of a GraalVM native image. The strategy granularity ranges from L0 (pure data) to L3 (PBR level effects), a total of 5 levels. The strategy selector adopts a lightweight decision tree.

[0013] Once the strategy is determined, the Renderlet immediately calls the local Vulkan subset command encoder to map the event workload into a GPU-executable triple instruction package: (1) a geometry compression package (Draco-encoded node-edge mesh), (2) a shader fingerprint (SPIR-V hash, 128 bit), and (3) an animation curve (a Bezier-based temporal-spatial sampling array). The three are encapsulated in the "render_payload" field of the event body and written to the event sourcing bus along with the business data via a zero-copy mmap channel.

[0014] Preferably, in the twin visualization engine module, the core of the engine is a "spatiotemporal-semantic dual-axis rendering pipeline". The spatial axis adopts a force-oriented-hierarchical hybrid layout, and the temporal axis adopts draggable time lattice discretization, with each lattice corresponding to the project's planned time. The node coordinates are determined by solving the following multi-objective energy equations in real time. The specific calculation method is as follows:

[0015]

[0016] Where E represents the final overall score. This is represented as the weighting coefficient for attribute relevance. It is represented as the attribute relevance function of the i-th element, which measures the attribute matching degree between it and the candidate point CP; The weighting coefficients are represented as the replacement cost. Let be the replacement cost function between the i-th element and the j-th element. Represented as semantic consistency weight coefficient, Let be the semantic fit function between the i-th element and the current stage. This is represented by the weight coefficient of the distance penalty term. This represents the distance from the i-th element to the camera;

[0017] The squared term indicates the use of a quadratic attenuation model, emphasizing the advantages of close-range operation or the high loss at long-range operation.

[0018]

[0019] in, This is represented as a scaling factor. It is represented as the geometric position vector of the i-th element. Let it be represented as the geometric position vector of the candidate point CP; here... Control the steepness of the function curve;

[0020]

[0021] in, This is represented as a scaling factor. Let the degree of the i-th element be represented. Let the degree of the j-th element be represented. Represented as the degree of the j-th element; The overall strength of the control function, β, determines the proportion of influence of the degree product and distance on the final score; for example:

[0022] → Standard proportional relationship;

[0023] →The effect of magnification product is to emphasize the importance of highly connected nodes;

[0024] → Smooth transition, allowing for reasonable scores even at greater distances;

[0025]

[0026] in, This is represented as a scaling factor. It is represented as the semantic vector of the i-th element. This is represented as a semantic vector of the target plan; the magnitude of γ determines the proportion of influence of semantic differences on the final score; for example:

[0027] →Square of standard Euclidean distance;

[0028] → Increase the penalty for semantic differences and emphasize strict matching;

[0029] → Smooth transition, allowing for some deviation.

[0030] coefficient , , , , The system is dynamically adjusted based on the user's perspective mode to ensure that nodes with higher delay risks are closer to the center of the visual cone.

[0031] Preferably, in the reverse control gateway module, when a user performs a "pinch-pull" gesture on a node in a twin scenario, the XR client immediately transmits the gesture vector. Pack the node ID into an IntentPacket, where θ and φ are spherical coordinate angles. This is the stretching factor; the gateway's Intention-Resolver uses a lightweight Transformer (2 layers, 16 heads, 1.1 M parameters) for inference within the edge Pod, outputting high-order intent labels, i.e.:

[0032]

[0033] Where n represents the node KPI vector, and c represents the current cluster capacity. Represented as time period weight;

[0034] If the confidence level is less than 0.85, the "Human in the Loop" pop-up window will appear; otherwise, a declarative YAML skeleton will be generated directly.

[0035] Command-Builder invokes the embedded "policy as code" template library based on the intent, rendering the parameters into governance commands that conform to native K8s and custom CRDs; the commands are not directly issued to the K8s API, but are first encapsulated into CompensationEvent and written to the event sourcing bus, with eventType="GovCommandIssued", and the payload contains command YAML, user ID, and intent vector hash;

[0036] The gateway also maintains an "Execution-Compensation" state machine table A, with each record as follows:

[0037]

[0038] in, Execute the compensation state machine table. This is represented as the event ID in the event sourcing bus. Represented as a cryptographic hash value of a declarative governance command. This represents a reversible compensation command. This is represented by the timestamp of the first time the command was issued. This represents the timeout period for the next status check.

[0039]

[0040] in, This is a function that calculates the next waiting time based on the current retries (retry). This represents the number of retries;

[0041] When the controller reports a failure, the gateway... Retry after step 'a' or switch to human assistance; if it still fails after 3 retries, it will automatically... Submit to the event bus for self-healing rollback.

[0042] Preferably, in the full-process project semantic knowledge graph module, the semantic extractor embeds a large domain model, runs in the edge Pod with 8-bit quantization, and a single inference takes less than 30 ms; the model output follows a predefined triple pattern.

[0043] To capture implicit dependencies, the extractor performs second-order inference within the message window: if the event stream sequentially shows "requirement change → test case addition → interface call volume increase", then a hyperedge is automatically created and instantiated as a virtual node in the graph to avoid relationship explosion; the edge weight real-time calculation engine triggers an incremental window every 30 seconds, taking into account three factors including microservice call latency factor, critical path fluctuation factor, and resource cost factor;

[0044] After being normalized by Min-Max, the three factors are used to obtain the final edge weights through a weighted geometric average. Weight updates trigger online graph convolution: the graph maintains a 2-layer GCN, with node embedding update rules, namely:

[0045]

[0046] in, Let represent the embeddings of all nodes in layer (l+1), D represent the degree matrix, A represent the weighted adjacency matrix, and W represent the learnable transformation matrix. This is represented as the embedding of all nodes in the l-th layer. It is represented as the trainable weight matrix of the l-th layer;

[0047] like This is represented by the standard deviation, indicating an outlier. The node is immediately highlighted in the twin scene, and the "counterfactual path" algorithm is activated: the suspicious node is virtually deleted in the embedding space, and the probability of downstream tasks being affected is recalculated. The specific calculation method is as follows:

[0048]

[0049] in, This represents the probability that downstream processes will be affected, and path represents a complete call path from the suspected root cause node to a downstream business node. This is represented as the combined weight of edge z;

[0050] according to The sorting returns a Top-Z root cause list, which, combined with one-click drill-down to logs, tracing, or the governance console, enables a three-hop closed loop of graph, metrics, and code.

[0051] The technical effects and advantages of this invention are as follows:

[0052] This invention implements business-level health checks and dynamic circuit breaking through a microservice registry center, and achieves low-latency visualization using embedded rendering instructions in an event tracing bus. The twin engine employs a dual-axis rendering pipeline and predictive loading, supporting multi-terminal interaction. The reverse control gateway converts user gestures into governance commands, achieving closed-loop control. The knowledge graph module dynamically locates the root cause of anomalies through real-time semantic extraction and graph computation. This invention's zero-intrusion "business semantic-level heartbeat" directly writes project KPIs into the registry center, allowing "project progress, cost, and quality" to become native health indicators without modifying a single line of business code. This completely eliminates the false positives of the traditional "port access ≠ business access" approach, and enables direct control in a visualized environment after anomalies are detected. Attached Figure Description

[0053] Figure 1 This is a schematic diagram of the module connection of the present invention.

[0054] Figure 2 This is a schematic diagram of the method flow of the present invention.

[0055] Figure 3 This is a schematic diagram of the reverse control gateway interaction process of the present invention. Detailed Implementation

[0056] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0057] Please see Figure 1 As shown, this invention provides a microservice-based end-to-end project visualization management system, including:

[0058] Microservice Registry Module: Used to register and perform health checks on several microservice instances in a dynamic service mesh topology. The health check includes a "business semantic level heartbeat" probe on the service instance, which carries a snapshot of the key performance indicators (KPIs) of the project stage currently being processed by the instance.

[0059] In the microservice registry module, during startup, the registry intercepts each instance's socket calls at the kernel layer using an eBPF probe, automatically injecting a lightweight "heartbeat sidecar" bytecode. This bytecode is activated after the instance's business thread completes any project phase state machine transition, immediately collecting the current phase's defined KPI quintuple: remaining project duration fluctuation ΔT, budget burn rate ∇C, requirement completion rate ρ, and defect density. The pass rate η of the deliverables review is calculated and encapsulated into a Protocol-KPI data packet using a zero-copy memory method. Subsequently, Sidecar-Beat sends the data packet back to the registry center using a pre-negotiated QUIC encrypted link. Upon receiving the heartbeat, the registry center projects the KPI quintuple into the three-dimensional risk tensor field (ΔT, ∇C, ρ×σ×η) in real time, and dynamically calculates the health equivalent hyperplane distance of the instance in the current project stage through online kernel density estimation. ;like If the bandwidth exceeds the historical μ±2σ, the registry center immediately triggers a "semantic-level circuit breaker". On the one hand, it sends a traffic coloring instruction to the service mesh data plane to divert subsequent requests to healthy neighbor instances proportionally. On the other hand, it writes the risk tensor coordinates into the event tracing bus, drives the twin visualization engine to render the instance node as the highest level visual alarm signal form, and pushes it to the project manager's AR glasses at the same time, realizing a zero-manual closed loop of business semantic anomaly - registry center - visualization.

[0060] The registry center has a built-in stage drift awareness unit: when the KPI five-tuple reported by the same instance in three consecutive heartbeats shows a stage ID jump (such as jumping from "requirements review" to "integration test"), the stage drift awareness unit automatically compares with the project WBS baseline. If it finds that the jump is ahead or behind the planned time window by more than 5%, it is determined to be "stage drift". It immediately generates a compensable "drift event" and writes it back to the event traceability bus, triggering the Workflow engine to dynamically rearrange subsequent dependent tasks, and at the same time update the project critical path edge weights in the knowledge graph.

[0061] The registry center adopts a "hierarchical random sampling - incremental Delta encoding" strategy: for large clusters with more than 5,000 instances, consistent hashing is first performed according to the project stage dimension, and 10% of the instances in each bucket are randomly sampled for full KPI back transmission, while the remaining instances only transmit the Delta vector with the previous full snapshot.

[0062] Event sourcing bus module: used to persist all domain events generated by microservices and embed a visual rendering instruction set in the event stream. The rendering instruction set is generated locally by the microservice that generated the event through the rendering strategy engine.

[0063] In the event sourcing bus module, each domain event is intercepted by a built-in lightweight Renderlet thread when the business aggregation root submits a change. This thread runs in the same process as the business logic but is located in an independent Loom virtual thread. It dynamically selects a pluggable rendering strategy by reading the "rendering context token" in the local thread local storage (TLS), which contains an 18-dimensional context including the current project stage, user view coordinates, terminal device pixel density, and GPU memory availability. The strategy library is pre-installed in the startup container layer in the form of a GraalVM native image. The strategy granularity ranges from L0 (pure data) to L3 (PBR level effects), a total of 5 levels. The strategy selector adopts a lightweight decision tree.

[0064] Once the strategy is determined, the Renderlet immediately invokes the local Vulkan subset command encoder to map the event workload into a GPU-executable triple instruction package: (1) a geometry compression package (Draco-encoded node-edge mesh), (2) a shader fingerprint (SPIR-V hash, 128 bit), and (3) an animation curve (a Bezier-based temporal-spatial sampling array). These three are encapsulated in the "render_payload" field of the event body and written to the event sourcing bus along with the business data via a zero-copy mmap channel. The bus itself is implemented by a "three-segment" persistent stack.

[0065] (1) Real-time segment: a memory-mapped Lock-Free Ring Buffer (capacity 256 k events) for the twin visualization engine to subscribe at 60 fps; the Lock-Free Ring Buffer is represented as a lock-free ring buffer;

[0066] (2) Temperature range: It adopts the columnar + JSON hybrid format of Apache Pinot, partitioned by project stage, and supports OLAP-level backtracking query; Apache Pinot represents a real-time distributed online analysis and processing system;

[0067] (3) Cold Segment: After the project milestone is achieved, the event flow is automatically converted into Parquet + Zstd compression and pushed to the decentralized Filecoin layer for off-chain cold storage of the visual audit package;

[0068] Consistency is ensured among the three segments through a "rendering instruction inheritance" mechanism: if a consumer misses an event in the real-time segment, it can retrieve the GPU command package for that event again in the warm segment through the instruction replay API and match the shader fingerprint in the local Vulkan cache pool;

[0069] To avoid bandwidth explosion caused by cross-regional replication, the event sourcing bus has a built-in "rendering instruction differential" algorithm: when the same aggregate root generates multiple events consecutively within a 500 ms window, the Renderlet generates a full instruction packet for the first event, and subsequent events only output the GPU command difference ΔCmd between the first event and the first event. The difference calculation is completed on the GPU side, using bitwise XOR + Run-Length encoding of SPIR-V intermediate code.

[0070] Meanwhile, the bus provides a "visual QoS" sidecar: when the twin visualization engine experiences a frame rate drop of less than 24 fps due to insufficient terminal performance, the engine sends a "degradation tag" back to the bus. The bus will then automatically downgrade the L3 level PBR effect to L1 level flat shading in the event stream within the next 5 seconds and notify all upstream microservice instances to temporarily switch rendering strategies.

[0071] Twin visualization engine module: used to parse the rendering instruction set and generate digital twin visualization scene in real time. The scene maps the microservice call chain and project stage milestones in a 3D node-edge graph manner, and supports the overlay of the heat texture of the KPI snapshot inside the node.

[0072] In the twin visualization engine module, the core of the engine is a "spatiotemporal-semantic dual-axis rendering pipeline". The spatial axis adopts a force-oriented-hierarchical hybrid layout, and the temporal axis adopts draggable time lattice discretization, with each lattice corresponding to the project's planned time. The node coordinates are determined by solving the following multi-objective energy equations in real time. The specific calculation method is as follows:

[0073]

[0074] Where E represents the final overall score. This is represented as the weighting coefficient for attribute relevance. It is represented as the attribute relevance function of the i-th element, which measures the attribute matching degree between it and the candidate point CP; The weighting coefficients are represented as the replacement cost. Let be the replacement cost function between the i-th element and the j-th element. Represented as semantic consistency weight coefficient, Let be the semantic fit function between the i-th element and the current stage. This is represented by the weight coefficient of the distance penalty term. This represents the distance from the i-th element to the camera;

[0075] The squared term indicates the use of a quadratic attenuation model, emphasizing the advantages of close-range operation or the high loss at long-range operation.

[0076]

[0077] in, This is represented as a scaling factor. It is represented as the geometric position vector of the i-th element. Let it be represented as the geometric position vector of the candidate point CP; here... Control the steepness of the function curve;

[0078]

[0079] in, This is represented as a scaling factor. Let the degree of the i-th element be represented. Let the degree of the j-th element be represented. Represented as the degree of the j-th element; The overall strength of the control function, β, determines the proportion of influence of the degree product and distance on the final score; for example:

[0080] → Standard proportional relationship;

[0081] →The effect of magnification product is to emphasize the importance of highly connected nodes;

[0082] → Smooth transition, allowing for reasonable scores even at greater distances;

[0083]

[0084] in, This is represented as a scaling factor. It is represented as the semantic vector of the i-th element. This is represented as a semantic vector of the target plan; the magnitude of γ determines the proportion of influence of semantic differences on the final score; for example:

[0085] →Square of standard Euclidean distance;

[0086] → Increase the penalty for semantic differences and emphasize strict matching;

[0087] → Smooth transition, allowing for some deviation.

[0088] coefficient , , , , Dynamically adjusted by the user's perspective mode to ensure that nodes with higher delay risk are closer to the center of the view cone;

[0089] The rendering loop is completed within 16 ms per frame: (1) The GPU reads the Render-Chunk from the event sourcing bus, (2) it is decoded in parallel using Compute Shader, and (3) node PBR materials and 256×256 KPI thermal textures are generated; the thermal textures are fast mapped using HSLA, and the specific calculation method is as follows:

[0090]

[0091]

[0092]

[0093]

[0094] in, Represented as hue value, S represents the degree of requirement fulfillment, N represents the degree of saturation, and L represents the degree of defect density. This is represented as a schedule deviation. Represented as a sign function; A represents transparency. This is expressed as the review pass rate; the formula ensures that the "green-yellow-red" gradient and transparency simultaneously reflect the three-dimensional risks of progress, quality, and schedule.

[0095] Example of a formula for calculating luminance L:

[0096]

[0097]

[0098] Engine built-in " "Predictor": Utilizing the user's viewpoint matrix and head angular velocity from the previous time lattice, the calculation method is as follows: (Specific calculation method follows)

[0099]

[0100] in, This is represented as the predicted user perspective matrix at time point t. This is represented as the actual user perspective matrix in the previous frame at time point t-1. Represented as a Jacobian perspective matrix, Expressed as head angular velocity, Represented as a time increment;

[0101] The set of visible nodes for the next frame is calculated 40 ms in advance. Only the visible nodes are loaded with high-poly models and thermal textures, while the remaining nodes are degenerated into 12-sided impostors.

[0102] When a user triggers the "Risk Focus" gesture, the engine immediately activates the "Pulse Wave" effect: a radial gradient animation is overlaid on the node surface, the intensity of which is determined by the root cause score s returned by the knowledge graph, and the pixel shader is pressed... Perform sampling. The specific calculation method is as follows:

[0103]

[0104] in, This is represented as the final output intensity of the pixel calculated at polar coordinates radius r and time t. Here, represents the basic strength coefficient, s represents the root cause score returned by the knowledge graph, and r represents the radial distance from the current pixel to the node center. Represented as wave speed, Let f represent the standard deviation of the Gaussian wave packet, and let f represent the oscillation frequency.

[0105] in, px stands for pixel. Represented as a frame, , This creates visual salience and guidance;

[0106] For the same frame, two OpenGL frame buffers are generated for the desktop client and a Vulkan exchange chain for the VR client. A 6-DoF minimap is additionally overlaid on the VR client, with the minimap node size adjusted according to... Dynamic scaling is performed; among which, This represents the actual display radius of the node on the minimap. denoted as the baseline node size, and s as the root cause score returned by the knowledge graph;

[0107] Ultimately, the twin visualization engine uses a "pixel-event" reverse mapping table to restore any screen pixel coordinates (u,v) to the corresponding event ID within 0.8 ms, enabling interpretable debugging through a three-hop "point-event-code" process. This completes a pixel-level, interactive, and predictable digital twin closed loop, from the microservice call chain to project milestones.

[0108] Reverse control gateway module: used to receive user interaction operations in the visualization scenario and convert the operations into declarative governance commands for the microservice cluster. The governance commands are written back as compensation events through the event sourcing bus to trigger the process re-arrangement of the corresponding microservice instance.

[0109] In the reverse control gateway module, when a user performs a "pinch-pull" gesture on a node in a twin scenario, the XR client immediately transmits the gesture vector. Pack the node ID into an IntentPacket, where θ and φ are spherical coordinate angles. This is the stretching factor; the gateway's Intention-Resolver uses a lightweight Transformer (2 layers, 16 heads, 1.1 M parameters) for inference within the edge Pod, outputting high-order intent labels, i.e.:

[0110]

[0111] Where n represents the node KPI vector, and c represents the current cluster capacity. Represented as time period weight;

[0112] If the confidence level is less than 0.85, the "Human in the Loop" pop-up window will appear; otherwise, a declarative YAML skeleton will be generated directly.

[0113] Command-Builder invokes the embedded "policy as code" template library based on the intent, rendering the parameters into governance commands that conform to native K8s and custom CRDs; the commands are not directly issued to the K8s API, but are first encapsulated into CompensationEvent and written to the event sourcing bus, with eventType="GovCommandIssued", and the payload contains command YAML, user ID, and intent vector hash;

[0114] The gateway also maintains an "Execution-Compensation" state machine table A, with each record as follows:

[0115]

[0116] in, Execute the compensation state machine table. This is represented as the event ID in the event sourcing bus. Represented as a cryptographic hash value of a declarative governance command. This represents a reversible compensation command. This is represented by the timestamp of the first time the command was issued. This represents the timeout period for the next status check.

[0117]

[0118] in, This is a function that calculates the next waiting time based on the current retries (retry). This represents the number of retries;

[0119] When the controller reports a failure, the gateway... Retry after step 'a' or switch to human assistance; if it still fails after 3 retries, it will automatically... Submit to the event bus for self-healing rollback;

[0120] To reduce accidental touches, all gestures on the XR side must include a "safety damping factor," namely:

[0121]

[0122] Where K represents the safety damping factor, Represented as the velocity vector norm of the gesture movement. Expressed as the damping coefficient;

[0123] when If the gesture is allowed to enter the gateway for processing, it will be judged as a browsing operation and consumed locally without occupying the cluster control plane.

[0124] Ultimately, the reverse control gateway, through the entire chain of "intent recognition → declarative commands → event-based compensation → automatic reverse," seamlessly maps any user interaction in the digital twin scenario into elastic governance of microservices and project processes.

[0125] The full-process project semantic knowledge graph module is used to extract semantics from the event stream and dynamically construct a project-task-microservice triple knowledge graph. The edge weights of the knowledge graph are calculated by combining microservice call latency, critical path fluctuations in project phases, and resource costs, and are located through anomaly root cause localization based on graph embedding.

[0126] In the semantic knowledge graph module of the entire project, the semantic extractor embeds a large domain model, runs in the edge Pod with 8-bit quantization, and a single inference takes less than 30 ms; the model output follows a predefined triple pattern.

[0127] To capture implicit dependencies, the extractor performs second-order inference within the message window: if the event stream sequentially shows "requirement change → test case addition → interface call volume increase", then a hyperedge is automatically created and instantiated as a virtual node in the graph to avoid relationship explosion; the edge weight real-time calculation engine triggers an incremental window every 30 seconds, taking into account three factors including microservice call latency factor, critical path fluctuation factor, and resource cost factor;

[0128] The specific method for calculating the latency factor of microservice calls is as follows:

[0129]

[0130] in, This is represented as the microservice call latency factor. This is expressed as an average delay of 5 minutes. This is represented as the corresponding SLA threshold;

[0131]

[0132] in, This is represented as the critical path floating factor. This represents the remaining floating number of days from task x to y. This represents the maximum fluctuation of the project;

[0133]

[0134] in, This represents the total consumption of the edge x→y within one hour. This represents the CPU consumption incurred when x calls y. This represents the memory consumption incurred when calling y from x. Represented as Consumption;

[0135] After being normalized by Min-Max, the three factors are then used to obtain the final edge weights through a weighted geometric mean. The specific calculation method is as follows:

[0136]

[0137] in, , , Represented as weighting factors;

[0138] Weight updates trigger online graph convolution: The graph maintains a 2-layer GCN, and node embedding update rules are used, namely:

[0139]

[0140] in, Let represent the embeddings of all nodes in layer (l+1), D represent the degree matrix, A represent the weighted adjacency matrix, and W represent the learnable transformation matrix. This is represented as the embedding of all nodes in the l-th layer. It is represented as the trainable weight matrix of the l-th layer;

[0141] Under normal operating conditions, the embedded space exhibits a clustering structure—microservices in the same project phase and within the same domain are close to each other on a 128-dimensional sphere; anomaly detection uses dynamic Mahalanobis distance, calculated as follows:

[0142]

[0143] in, Let it be the Mahalanobis distance of node i. This is represented as the embedding vector of node b. It is represented as the mean vector of category c;

[0144] like This is represented by the standard deviation, indicating an outlier. The node is immediately highlighted in the twin scene, and the "counterfactual path" algorithm is activated: the suspicious node is virtually deleted in the embedding space, and the probability of downstream tasks being affected is recalculated. The specific calculation method is as follows:

[0145]

[0146] in, This represents the probability that downstream processes will be affected, and path represents a complete call path from the suspected root cause node to a downstream business node. This is represented as the combined weight of edge z;

[0147] according to The sorting returns a Top-Z root cause list, which, combined with one-click drill-down to logs, tracing, or the governance console, enables a three-hop closed loop of graph, metrics, and code.

[0148] Please see Figure 2 As shown, this invention also provides a microservice-based end-to-end project visualization management method, including:

[0149] A1: Register and perform health checks on several microservice instances using a dynamic service mesh topology. The health check includes a "business semantic level heartbeat" probe on the service instances, which carries a snapshot of the key performance indicators (KPIs) of the current project phase being processed by the instance.

[0150] A2: Persist all domain events generated by microservices and embed a set of visual rendering instructions into the event stream. The set of rendering instructions is generated locally by the microservice that generates the event through the rendering strategy engine.

[0151] A3: Parse the rendering instruction set and generate a digital twin visualization scene in real time. The scene maps the microservice call chain and project stage milestones in a three-dimensional node-edge graph manner.

[0152] A4: Receive user interaction operations in the visualization scenario and convert the operations into declarative governance commands for the microservice cluster. The governance commands are written back as compensation events through the event sourcing bus, triggering the process re-arrangement of the corresponding microservice instance.

[0153] A5: Semantic extraction is performed on the event stream and a project-task-microservice triple knowledge graph is dynamically constructed. The edge weights of the knowledge graph are calculated by combining the microservice call latency, the critical path fluctuation of the project stage, and the resource cost. Furthermore, the root cause of anomalies is located through graph embedding.

[0154] In conclusion, the above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A whole-process project visual management system based on microservices, characterized in that, Comprise: A microservice registry module for registering and health checking microservice instances in a dynamic service mesh topology, the health checking including "business semantic level heartbeat" probing of service instances, the business semantic level heartbeat carrying a key performance indicator (KPI) snapshot of a current project phase being processed by the instance; an event sourcing bus module for persisting all domain events generated by microservices and embedding a set of visualization rendering instructions in an event stream, the set of rendering instructions being generated by a microservice generating an event locally via a rendering strategy engine in real time; a twin visualization engine module for parsing the set of rendering instructions and generating a digital twin visualization scene in real time, the scene mapping microservice call links and project phase milestones in a three-dimensional node-edge graph manner; A reverse control gateway module for receiving user interaction operations in the visualization scene and converting the operations into declarative governance commands for a microservice cluster, the governance commands being written back as compensation events via the event sourcing bus to trigger process rearrangement of corresponding microservice instances; A whole-process project semantic knowledge graph module for performing semantic extraction on the event stream and dynamically constructing a project-task-microservice triple knowledge graph, edge weights of the knowledge graph being calculated jointly based on microservice call delay, project phase critical path float, and resource cost, and abnormal root cause being located based on graph embedding. 2.The micro-service based whole-process project visual management system according to claim 1, characterized in that: In the microservice registry center module, the registry center hijacks the socket call of each instance at the kernel layer through the eBPF probe at the startup stage, automatically injects a lightweight "heartbeat sidecar" bytecode, which is activated after the instance business thread handles any project phase state machine conversion, immediately collects the KPI five-tuple defined in the current phase, i.e. the remaining duration float ΔT, budget burning rate ∇C, demand completion degree , defect density and delivery review pass rate η, and encapsulates it as a Protocol-KPI data packet in a memory zero-copy manner; then, Sidecar-Beat uses the pre-negotiated QUIC encryption link to send the data packet back to the registry center, and after receiving the heartbeat, the registry center projects the KPI five-tuple into the three-dimensional risk tensor field (ΔT, ∇C, × ×η), dynamically calculates the health equivalent hyperplane distance of the instance in the current project phase through online kernel density estimation ; if it exceeds the historical μ±2σ bandwidth, the registry center immediately triggers "semantic-level fuse", on the one hand, issues traffic dyeing instructions to the service mesh data plane, and directs subsequent requests to healthy neighbor instances in proportion, on the other hand, writes the risk tensor coordinates into the event trace bus, and drives the twin visualization engine to render the instance node as the highest level visual alarm signal form. 3.The micro-service based whole-process project visual management system according to claim 1, characterized in that: In the event sourcing bus module, each domain event is intercepted by a built-in Renderlet lightweight thread when a business aggregate root submits a change, the thread running in the same process as business logic and being located in an independent Loom virtual thread, a pluggable rendering strategy being dynamically selected by reading a rendering context token in a thread local storage (TLS); A strategy library is pre-installed in a start container layer in the form of a GraalVM native image, there are four levels of strategies from L0 to L3, and a lightweight decision tree is used as a strategy selector; after the strategy is determined, the Renderlet calls a local Vulkan subset command encoder to map event business load into a GPU executable triple instruction, the three being encapsulated into a render_payload field of an event body and written into the event sourcing bus together with business data via a zero-copy mmap channel. 4.The micro-service based whole-process project visual management system according to claim 1, characterized in that: In the twin visualization engine module, the engine core is a "space-time semantic double-axis rendering pipeline", the space axis adopts force-oriented-hierarchical hybrid layout, and the time axis adopts a dragable time lattice discretization, each lattice corresponding to a project planning time The node coordinates are determined by real-time solving of the following multi-objective energy equation, and the calculation method is specifically as follows: Wherein, E represents the final comprehensive score, represents the weight coefficient of attribute relevance, represents the attribute relevance function of the i-th element, which measures the attribute matching degree with the candidate point CP; represents the weight coefficient of the replacement cost, represents the replacement cost function between the i-th element and the j-th element, represents the semantic consistency weight coefficient, represents the semantic adaptation function of the i-th element and the current stage stage, represents the weight coefficient of the distance penalty term, represents the distance of the i-th element to the camera; the rendering cycle is completed within 16 ms per frame, the GPU reads the Render-Chunk of the event trace bus, parallel decoding is performed by using the Compute Shader, node PBR materials and 256x256 KPI heat texture are generated. 5.The micro-service based whole-process project visual management system according to claim 4, characterized in that: The thermal texture uses HSLA fast mapping, and the calculation method is as follows: in, Represented as hue value, S represents the degree of requirement fulfillment, N represents the degree of saturation, and L represents the degree of defect density. This is represented as a schedule deviation. Represented as a sign function; A represents transparency. This is expressed as the review pass rate; the formula ensures that the "green-yellow-red" gradient and transparency simultaneously reflect the three-dimensional risks of progress, quality, and schedule; the engine has built-in... "Predictor": Utilizes the user's viewpoint matrix and head angular velocity from the previous time lattice, extrapolating via a first-order Taylor series; when the user triggers the "Risk Focus" gesture, the engine immediately activates the "Pulse Wave" effect: a radial gradient animation is superimposed on the node surface, its intensity determined by the root cause score s returned by the knowledge graph, and the pixel shader is adjusted accordingly. Perform sampling. The specific calculation method is as follows: in, This is represented as the final output intensity of the pixel calculated at polar coordinates radius r and time t. Here, represents the basic strength coefficient, s represents the root cause score returned by the knowledge graph, and r represents the radial distance from the current pixel to the node center. Represented as wave speed, The standard deviation of the Gaussian wave packet is represented by f, and the oscillation frequency is represented by f. OpenGL frame buffers are generated for the desktop and a Vulkan exchange chain is used for the VR. A 6-DoF minimap is additionally overlaid on the VR. The minimap node size is determined by... Dynamic scaling is performed; finally, the twin visualization engine uses a "pixel-event" reverse mapping table to restore any screen pixel coordinates (u,v) to the corresponding event ID within 0.8 ms. 6.The microservice-based whole-process project visual management system according to claim 1, characterized in that: In the reverse control gateway module, when a user performs a "pinch-out" gesture on a certain node in a twin scene, the XR client immediately sends the gesture vector to the gateway packed with the node ID as an IntentPacket, where θ, φ are spherical coordinate angles, is the stretching coefficient; the Intention-Resolver of the gateway uses a lightweight Transformer to infer within the edge Pod, outputting high-order intention labels; the Command-Builder calls the embedded "policy-as-code" template library according to the intention, rendering the parameters into governance commands conforming to K8s native and custom CRD; the command is not directly issued to the K8s API, but first encapsulated into a CompensationEvent and written into the event trace bus, eventType="GovCommandIssued", and the payload contains the command YAML, user ID, and intention vector hash.

7. The microservice-based whole-process project visual management system according to claim 6, characterized in that: The gateway maintains a table A of "execute-compensate" state machines, each record is: wherein, the execute-compensate state machine, is represented as an event ID in the event trace bus, is represented as a cryptographic hash of the declarative governance command, is represented as a reversible compensating command, is represented as a timestamp of the first issuance of the command, is represented as a wait timeout for the next state check; all gestures on the XR side are accompanied by a security damping factor, namely: wherein, K is represented as a security damping factor, is represented as the norm of the velocity vector of the gesture movement, is represented as a damping coefficient; when the gateway processing is allowed to enter; otherwise, the gesture is determined as a browsing operation, directly consumed locally, and does not occupy the cluster control plane. 8.The micro-service based whole-process project visual management system according to claim 1, characterized in that: In the full-process project semantic knowledge graph module, the semantic extractor is embedded with a domain large model, which runs in the edge Pod with 8-bit quantization, and the model output follows a predefined triple pattern. The extractor performs second-order reasoning in the message window: if the event stream appears in the order of "demand change → test case addition → interface call volume increase", an hyperedge is automatically created and instantiated as a virtual node in the graph; the edge weight real-time calculation engine triggers an incremental window every 30 seconds; three factors including microservice call delay factor, critical path float factor and resource cost factor are integrated; after Min-Max normalization, the final edge weight is obtained through weighted geometric mean, and weight update triggers online graph convolution: the graph maintains a 2-layer GCN, and the node embedding update rule; the embedding space presents a clustering structure-the microservices in the same project phase and the same domain are close to each other in 128-dimensional spherical surface; Anomaly detection uses dynamic Mahalanobis distance; if the Mahalanobis distance is greater than That is, it is determined to be an outlier, immediately highlights the node in the twin scene, and starts the "counterfactual path" algorithm: virtually deletes the suspicious node in the embedding space, and recalculates the affected probability of downstream tasks.

9. The method for visual management of whole-process project based on microservices, using the system for visual management of whole-process project based on microservices according to any one of claims 1-8, characterized in that: A1: register and health check a number of microservice instances in a dynamic service mesh topology, the health check includes "business semantic level heartbeat" detection of service instances, which carries the key performance indicator KPI snapshot of the current project phase handled by the instance; A2: persist all domain events generated by microservices, and embed visual rendering instruction set in the event stream, which is generated by the microservice that generates the event and is generated locally by the rendering strategy engine in real time; A3: analyze the rendering instruction set and generate a digital twin visualization scene in real time, which maps the microservice call link and project phase milestone in a three-dimensional node-edge graph; A4: receive user interaction operations in the visualization scene, and convert the operations into declarative governance commands for the microservice cluster, the governance commands are written back as compensation events through the event traceability bus, triggering process rearrangement of corresponding microservice instances; A5: perform semantic extraction on the event stream and dynamically build a project-task-microservice triple knowledge graph, the edge weight of the knowledge graph is calculated by the joint calculation of microservice call delay, project phase critical path float and resource cost, and the abnormal root cause is located based on graph embedding.

Images