An application backtracking method, device and electronic equipment

Abstract

Embodiments of the present application provide an application rollback method and device and electronic equipment, and relate to the technical field of computers, to improve the diagnosis efficiency of abnormal problems and user satisfaction. The method comprises: obtaining session data of the current session of the application, the session data representing a set of interaction behaviors of an interaction object with the application within the current time period, the session data including session view data and session basic data, the session view data including native view data and H5 view data, and the session basic data including multidimensional session data and associated information of the multidimensional session data; storing the session basic data and providing an API interface supporting multidimensional session data queries, so that a target object can query the multidimensional session data through the associated information; and synchronously rendering playback content of the native view and the H5 view according to the session view data through a front-end player, so that the target object can locate abnormal problems based on the playback content.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to an application backtracking method, apparatus, and electronic device. Background Technology

[0002] With the continuous development of the mobile internet and the intensification of market competition, mobile application developers are paying increasing attention to the user experience on the client side. However, in practical applications, users often encounter abnormal situations when using the application, and users will report these abnormalities.

[0003] In existing technologies, the handling process for customer feedback issues heavily relies on manual recording and analysis, which is inefficient and prone to missing key information. Specifically, users typically report issues via customer service phone calls or messages. Customer service personnel are responsible for handling and recording the issues, and the recorded customer complaint tickets usually only include the user's identifier (e.g., mobile phone number or email address), a general description of the problem, and basic device information (e.g., device model and operating system).

[0004] However, when the simplified customer complaint ticket content is fed back to the R&D department for investigation, the following pain points are often exposed: (1) The user scenario is unclear and difficult to reproduce: The customer complaint tickets recorded by customer service personnel often lack a detailed description of the user's actual usage scenario. It is difficult for R&D personnel to accurately understand the specific context and operation path of the user's problem through limited text information, which makes it difficult to reproduce the problem; (2) The client environment information is lacking: The customer complaint ticket usually lacks detailed on-site information when the device is abnormal or erroneous, including: key network request data, user interaction operation data, page status data, event data and abnormal call stack information, etc., which makes it impossible for R&D personnel to grasp the complete technical environment when the problem occurs, which greatly hinders the efficient investigation and resolution of the problem. Summary of the Invention

[0005] This application provides an application backtracking method, apparatus, and electronic device to solve the technical problems in the background art, such as low efficiency, incomplete data, and difficulty in reproducing and locating problems caused by manual recording and analysis of anomalies. Through automated, comprehensive, and cross-terminal on-site data collection and correlation analysis, as well as the generation of playback content, the diagnostic efficiency of anomalies and user satisfaction are significantly improved.

[0006] In a first aspect, embodiments of this application provide an application backtracking method, the method comprising:

[0007] Retrieve session data for the current session of the application. Session data represents the collection of interactive behaviors between the interactive object and the application within the current time period. Session data includes: session view data and session basic data. Session view data includes: native view data and H5 view data. Session basic data includes: multi-dimensional session data and related information of multi-dimensional session data.

[0008] The basic session data is stored, and an API interface that supports multi-dimensional session data querying is provided, so that the target object can query multi-dimensional session data through related information;

[0009] The front-end player synchronously renders the playback content of the native view and H5 view based on the session view data, so that the target object can locate the abnormal problem based on the playback content.

[0010] In one optional embodiment, obtaining the session data of the application for the current session includes:

[0011] Through the client, multi-dimensional session data of the current session of the application is collected, and the identifiers between the multi-dimensional session data are associated to obtain the association information of the multi-dimensional session data;

[0012] Session view data is collected through the client.

[0013] In one optional embodiment, the association information of the multi-dimensional session data is obtained by associating the identifiers between the multi-dimensional session data, including:

[0014] When the application starts, a device identifier and a session identifier are generated, and the object identifier of the interactive object is associated with the device identifier, and the session identifier is associated with the device identifier and the user identifier.

[0015] When an interactive object accesses a native page, a view identifier is generated and associated with a monogram identifier;

[0016] When an interactive object performs an interactive operation on the native page, an operation identifier is generated and associated with the view identifier and the session identifier;

[0017] When a network request occurs, a tracking identifier is generated and transmitted in the network request header, and the tracking identifier is associated with the identifier of the parent node that initiated the network request, where the parent node is a native page or an interactive operation.

[0018] In one optional embodiment, session view data is collected via a client, including:

[0019] By listening to changes in the lifecycle methods of the native view through a hook mechanism, the timing for taking a screenshot of the native view can be identified and triggered. The screenshot is then taken when the interaction action of the interactive object is triggered, and the native view data is obtained.

[0020] By injecting JavaScript probes into the webpage view, we can listen for changes in DOM elements and MutationObserver events on the H5 page to obtain H5 view data.

[0021] In an optional embodiment, the method further includes:

[0022] When a screenshot command is received, if the distance between the current time and the last screenshot time is greater than the preset minimum time interval, the screenshot operation will be executed.

[0023] In one alternative embodiment, after acquiring the session view data, the method further includes:

[0024] Compression and resolution control of session view data are achieved through client-side processing;

[0025] Through the client, privacy elements contained in the session view data are identified and hidden according to preset privacy rules.

[0026] In one optional embodiment, the native view data includes: native view data of the embedded H5 page, which includes: location information, size information, and webpage view identifier of the embedded H5 page;

[0027] The front-end player includes a native view renderer and a web page view renderer. The web page view renderer maintains the web player instance corresponding to the web page view identifier.

[0028] In one optional embodiment, the playback content of the native view and the H5 view is rendered synchronously by the front-end player based on the session view data, so that the target object can locate the abnormal problem based on the playback content, including:

[0029] Playback is driven by the native view renderer's playback timer, and the rendering area, scaling ratio, and position of the Web player instance are dynamically adjusted based on position and size information to synchronously render the playback content of the native view and H5 view.

[0030] In an optional embodiment, the method further includes:

[0031] When the playback content jumps to a point where there is an H5 page container component but no H5 view data, a web page view renderer is created and the timer of the web page view renderer is made to run in idling.

[0032] When the playback content jumps to a point in time where H5 view data is available, the H5 view data is loaded and the player time is synchronized.

[0033] Secondly, embodiments of this application also provide an application rollback device, the device comprising:

[0034] The acquisition module is used to acquire the session data of the application in the current session. The session data represents the set of interactive behaviors between the interactive object and the application within the current time period. The session data includes: session view data and session basic data. The session view data includes: native view data and H5 view data. The session basic data includes: multi-dimensional session data and the association information of multi-dimensional session data.

[0035] The processing module stores basic session data and provides an API interface that supports multi-dimensional session data queries, enabling target objects to query multi-dimensional session data through associated information.

[0036] The playback module is used to synchronously render the playback content of the native view and H5 view based on the session view data through the front-end player, so that the target object can locate the abnormal problem based on the playback content.

[0037] In one optional embodiment, when obtaining session data for the current session of the application, the acquisition module is used to:

[0038] Through the client, multi-dimensional session data of the current session of the application is collected, and the identifiers between the multi-dimensional session data are associated to obtain the association information of the multi-dimensional session data;

[0039] Session view data is collected through the client.

[0040] In one optional embodiment, when obtaining the association information of multi-dimensional session data by associating the identifiers between them, the acquisition module is used to:

[0041] When the application starts, a device identifier and a session identifier are generated, and the object identifier of the interactive object is associated with the device identifier, and the session identifier is associated with the device identifier and the user identifier.

[0042] When an interactive object accesses a native page, a view identifier is generated and associated with a monogram identifier;

[0043] When an interactive object performs an interactive operation on the native page, an operation identifier is generated and associated with the view identifier and the session identifier;

[0044] When a network request occurs, a tracking identifier is generated and transmitted in the network request header, and the tracking identifier is associated with the identifier of the parent node that initiated the network request, where the parent node is a native page or an interactive operation.

[0045] In one optional embodiment, when collecting session view data via a client, the acquisition module is used to:

[0046] By listening to changes in the lifecycle methods of the native view through a hook mechanism, the timing for taking a screenshot of the native view can be identified and triggered. The screenshot is then taken when the interaction action of the interactive object is triggered, and the native view data is obtained.

[0047] By injecting JavaScript probes into the webpage view, we can listen for changes in DOM elements and MutationObserver events on the H5 page to obtain H5 view data.

[0048] In one optional embodiment, the acquisition module is used to:

[0049] When a screenshot command is received, if the distance between the current time and the last screenshot time is greater than the preset minimum time interval, the screenshot operation will be executed.

[0050] In an optional embodiment, after acquiring the session view data, the acquisition module is further configured to:

[0051] Compression and resolution control of session view data are achieved through client-side processing;

[0052] Through the client, privacy elements contained in the session view data are identified and hidden according to preset privacy rules.

[0053] In one optional embodiment, the native view data includes: native view data of the embedded H5 page, which includes: location information, size information, and webpage view identifier of the embedded H5 page;

[0054] The front-end player includes a native view renderer and a web page view renderer. The web page view renderer maintains the web player instance corresponding to the web page view identifier.

[0055] In one optional embodiment, the playback module is used to synchronously render the playback content of the native view and the H5 view based on the session view data through the front-end player, so that when the target object locates the abnormal problem based on the playback content, the playback module is used to:

[0056] Playback is driven by the native view renderer's playback timer, and the rendering area, scaling ratio, and position of the Web player instance are dynamically adjusted based on position and size information to synchronously render the playback content of the native view and H5 view.

[0057] In an optional embodiment, the playback module is further configured to:

[0058] When the playback content jumps to a point where there is an H5 page container component but no H5 view data, a web page view renderer is created and the timer of the web page view renderer is made to run in idling.

[0059] When the playback content jumps to a point in time where H5 view data is available, the H5 view data is loaded and the player time is synchronized.

[0060] Thirdly, embodiments of this application also provide an electronic device, including:

[0061] Processor; and

[0062] Stored program memory,

[0063] The program includes instructions that, when executed by the processor, cause the processor to perform the application backtracking method as described in the first aspect.

[0064] Fourthly, embodiments of this application also provide a non-transitory computer-readable storage medium storing computer instructions, wherein the computer instructions are used to cause a computer to execute the application backtracking method as described in the first aspect.

[0065] Fifthly, this application provides a computer program product that, when invoked by a computer, causes the computer to execute the application backtracking method steps as described in the first aspect.

[0066] The beneficial effects of this application are as follows:

[0067] In the application backtracking method provided in this application embodiment, the session view data includes native view data and H5 view data, and the session basic data includes multi-dimensional session data and related information of multi-dimensional session data. The acquired session basic data is stored, and an API interface supporting multi-dimensional session data query is provided, allowing the target object to query multi-dimensional session data through related information. Simultaneously, through the front-end player, the playback content of the native view and H5 view is rendered synchronously based on the session view data, enabling the target object to locate the abnormal problem based on the playback content. In this way, through comprehensive and detailed session data collection, this invention can completely record the real behavior path and on-site environment of the interactive object within the application, greatly making up for the shortcomings of manual work order records, enabling R&D personnel to reproduce the problem scenario with high fidelity and improve troubleshooting efficiency. At the same time, by revisiting through session view data, all behaviors and content of the interactive object during cross-platform switching can be completely and coherently traced back, providing unprecedented capabilities for accurately reconstructing the problem scene, significantly shortening the fault diagnosis time, and thus significantly improving customer satisfaction.

[0068] Furthermore, other features and advantages of this application will be set forth in the following description and will be apparent in part from the description, or may be learned by practicing the application. The objectives and other advantages of this application may be realized and obtained by means of the structures particularly pointed out in the written description, claims, and drawings. Attached Figure Description

[0069] To more clearly illustrate the technical solutions in the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described herein are used to provide a further understanding of this application, constitute a part of this application, and do not constitute an improper limitation of this application. In the accompanying drawings:

[0070] Figure 1 This is a schematic diagram illustrating the content of a customer complaint work order applicable to an embodiment of this application;

[0071] Figure 2 This is a schematic diagram of an optional system architecture applicable to the embodiments of this application;

[0072] Figure 3 A schematic diagram illustrating the implementation process of an application backtracking method provided in this application embodiment;

[0073] Figure 4 A schematic diagram of the native view of the embedded H5 page provided in the embodiments of this application;

[0074] Figure 5 A schematic diagram illustrating the process of session view data acquisition and storage provided in an embodiment of this application;

[0075] Figure 6 A flowchart illustrating the recording of a single frame screenshot provided in this application embodiment;

[0076] Figure 7 This is a schematic diagram illustrating client-side data upload provided in an embodiment of this application.

[0077] Figure 8 This is a schematic diagram of query session data provided in an embodiment of this application;

[0078] Figure 9 A schematic diagram of the structure of an application backtracking device provided in an embodiment of this application;

[0079] Figure 10 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Detailed Implementation

[0080] Embodiments of this application will now be described in more detail with reference to the accompanying drawings. While some embodiments of this application are shown in the drawings, it should be understood that this application can be implemented in various forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided to provide a more thorough and complete understanding of this application. It should be understood that the drawings and embodiments of this application are for illustrative purposes only and are not intended to limit the scope of protection of this application.

[0081] It should be understood that the steps described in the method embodiments of this application may be performed in different orders and / or in parallel. Furthermore, the method embodiments may include additional steps and / or omit the steps shown. The scope of this application is not limited in this respect.

[0082] The term "comprising" and its variations as used herein are open-ended, meaning "including but not limited to". The term "based on" means "at least partially based on". The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments". Definitions of other terms will be given in the following description. It should be noted that the concepts of "first", "second", etc., mentioned in this application are used only to distinguish different devices, modules, or units, and are not intended to limit the order of functions performed by these devices, modules, or units or their interdependencies.

[0083] It should be noted that the terms "a" and "a plurality of" used in this application are illustrative rather than restrictive, and those skilled in the art should understand that, unless otherwise expressly indicated in the context, they should be understood as "one or more".

[0084] The names of the messages or information exchanged between multiple devices in the embodiments of this application are for illustrative purposes only and are not intended to limit the scope of these messages or information.

[0085] The design concept of the embodiments of this application is briefly introduced below:

[0086] With the continuous development of the mobile internet and the intensification of market competition, mobile application developers are paying increasing attention to the user experience on the client side. However, in practical applications, users often encounter abnormal situations when using the application, and users will report these abnormalities.

[0087] In existing technologies, the handling process for customer feedback issues heavily relies on manual recording and analysis, which is inefficient and prone to missing key information. Specifically, users typically report issues via customer service phone calls or messages. Customer service personnel are responsible for handling and recording the issues, and the recorded customer complaint tickets usually only include the user's identifier (e.g., mobile phone number or email address), a general description of the problem, and basic device information (e.g., device model and operating system).

[0088] For example, the content of a customer complaint work order is as follows: Figure 1 As shown.

[0089] However, when the simplified customer complaint ticket content is fed back to the R&D department for investigation, the following pain points are often exposed: (1) The user scenario is unclear and difficult to reproduce: The customer complaint tickets recorded by customer service personnel often lack a detailed description of the user's actual usage scenario. It is difficult for R&D personnel to accurately understand the specific context and operation path of the user's problem through limited text information, which makes it difficult to reproduce the problem; (2) The client environment information is lacking: The customer complaint ticket usually lacks detailed on-site information when the device is abnormal or erroneous, including: key network request data, user interaction operation data, page status data, event data and abnormal call stack information, etc., which makes it impossible for R&D personnel to grasp the complete technical environment when the problem occurs, which greatly hinders the efficient investigation and resolution of the problem.

[0090] In view of this, this application proposes an application backtracking method, which may include: first, acquiring the session data of the current session of the application, wherein the session data represents the set of interactive behaviors between the interactive object and the application within the current time period, and the session data includes: session view data and session basic data, wherein the session view data includes: native view data and H5 view data, and the session basic data includes: multi-dimensional session data and the association information of the multi-dimensional session data; then, storing the session basic data and providing an API interface that supports multi-dimensional session data query, so that the target object can query the complete session data through the association information; and then, through the front-end player, synchronously rendering the playback content of the native view and H5 view based on the session view data, so that the target object can locate the abnormal problem based on the playback content.

[0091] By employing the above method and collecting comprehensive and detailed session data, this invention can completely record the actual behavioral paths and on-site environments of interactive objects within mobile applications, greatly compensating for the shortcomings of manual work order records. This enables developers to reproduce problem scenarios with high fidelity, improving troubleshooting efficiency. Simultaneously, by revisiting through view data, it is possible to completely and coherently trace all behaviors and content of interactive objects during cross-platform switching, providing unprecedented capabilities for accurately reconstructing the problem scene, significantly shortening troubleshooting time, and thus significantly improving customer satisfaction.

[0092] In particular, the preferred embodiments of this application will be described below with reference to the accompanying drawings. It should be understood that the preferred embodiments described herein are for illustration and explanation only and are not intended to limit this application. Furthermore, the embodiments of this application and the features in the embodiments can be combined with each other without conflict.

[0093] See Figure 2 As shown, it is a schematic diagram of an optional system architecture applicable to the embodiments of this application. The system architecture may include: client 201, backend service module 202, frontend player 203 and data analysis and display module 204.

[0094] The client 201 includes an SDK module, which is deployed in the application and is used to collect session data of the current session of the application, compress and store it locally, and send the session data to the backend 202. It also has built-in privacy element masking logic.

[0095] After receiving session data from client 201, backend service module 202 stores the basic session data and provides an API interface supporting multi-dimensional session data queries. This allows the target object to query complete session data using the associated information. Furthermore, the frontend player synchronously renders playback content of the native view and H5 view based on the session view data, enabling the target object to locate anomalies based on the playback content. It also provides a unified privacy policy configuration distribution service.

[0096] The front-end player 203 is deployed on the monitoring platform to integrate native view data and H5 view data. Through a layered rendering architecture and complex synchronization logic, it achieves seamless, high-fidelity fusion and playback of native view and embedded H5 view content, and supports multi-dimensional synchronous display of data such as user trajectory, network requests, and view changes.

[0097] The data analysis and visualization module 204 is configured to perform in-depth analysis of the collected session data, including user behavior path analysis, performance bottleneck identification, error and crash diagnosis, and present the analysis results intuitively in the form of visual reports, view playback, etc., to help R&D and business personnel quickly locate and resolve customer complaints.

[0098] The application backtracking method provided by the exemplary embodiments of this application will be described below in conjunction with the above system architecture and with reference to the accompanying drawings. It should be noted that the above system architecture is only shown for the purpose of understanding the spirit and principles of this application, and the embodiments of this application are not limited in any way.

[0099] See Figure 2The diagram illustrates the implementation flow of an application backtracking method provided in this embodiment. Taking a backend service module as an example, the specific implementation flow of this method is as follows:

[0100] S30: Get the session data for the current session of the application.

[0101] Among them, session data representation is the set of interactive behaviors between the interactive object and the application within the current time period. Session data includes: session view data and session basic data. Session view data includes: native view data and H5 view data. Session basic data includes: multi-dimensional session data and related information of multi-dimensional session data.

[0102] In this embodiment, a session typically encompasses the interaction object (i.e., the user) opening the application, performing a series of operations, until the session ends (e.g., exiting the application or timeout due to prolonged inactivity). The start of a session is defined as the moment when the interaction object launches the application and begins interacting with it. Any of the following situations can be considered the start of a session: (1) the interaction object clicks the application icon to launch the application; (2) the application is reactivated by the interaction object after running in the background; (3) the interaction object launches the application via push notification or deep link. The end of a session is defined as the moment when the interaction object stops interacting with the application and exits the application, or when the session times out due to prolonged inactivity. Any of the following situations can be considered the end of a session: (1) the interaction object manually exits the application; (2) the application is moved to the background and is not reactivated within a preset activation period (e.g., 30 minutes); (3) the interaction object's device is powered off or restarted; (4) the application crashes / freezes. Session timeout refers to the situation where the interactive object does not interact with the application within a preset activation period (e.g., 30 minutes), and the system automatically considers the current session to be over. The preset activation period can be adjusted according to application characteristics and user behavior patterns.

[0103] Optionally, in this embodiment of the application, a session includes the following basic attributes to uniquely identify and describe the session: (1) Session identifier (i.e., session ID): an identifier that uniquely identifies a session; (2) Object identifier of the interaction object (i.e., user ID): an identifier that uniquely identifies the interaction object; (3) Device information: relevant information about the device of the interaction object (e.g., device model, operating system version, etc.); (4) Start time: timestamp of the start of the session; (5) End time: timestamp of the end of the session; (6) Duration: the total duration of the session; (7) Interaction events: a list of all key interaction events of the interaction object during the session, including: user events (e.g., click, touch, swipe, etc.) and system events (e.g., network switching (4G, 5G, Wi-Fi), application foreground / background switching, etc.).

[0104] In this embodiment, the client collects the basic session data of the application's current session. Specifically, the basic session data includes multi-dimensional session data and association information between the multi-dimensional session data. The client collects the multi-dimensional session data of the application's current session and associates the identifiers between the multi-dimensional session data to obtain the association information.

[0105] For example, multi-dimensional session data includes, but is not limited to: (1) basic information, (2) user information, (3) session information, (4) user events, (5) network data, (6) native performance data processing, and (7) web performance data processing. (1) Basic information includes: device model, operating system version, screen resolution, device identifier (e.g., UUID), application version number, and application package name. (2) User information includes: the object identifier of the interaction object (which may be the user login name, user ID, or anonymous ID), used to uniquely identify the interaction object. (3) Session information includes: session identifier (i.e., session ID), session start time, session end time, session duration, and session status (e.g., normal termination, timeout, or abnormal interruption). (4) User events include: page browsing, click events, swiping and scrolling, form input, and interaction events; page browsing includes: the name of the page visited by the user, the time of entering and leaving the page, and the page identifier; click events are: the button or link clicked by the user, and the click event includes the click location, timestamp, target page or function, and operation identifier; swiping and scrolling are: the user's swiping and scrolling behavior on the page, and swiping and scrolling include swiping distance and direction; form input is: the content entered by the user in the form (excluding sensitive information), such as search keywords and input box content; interaction events are: other interaction behaviors between the interactive object and the application, such as long press, double tap, gesture operation, etc. (5) Network data includes: requests and responses, network status; requests and responses are: network request and response information between the application and the server, including: request type, Uniform Resource Locator (URL), response time, status code, request header, request body, response header and response body data, and tracking identifier; network status includes: the network connection status of the device of the interactive object (such as Wi-Fi, 4G, 5G) and network quality indicators (such as latency, bandwidth). (6) Native performance data processing includes: startup time, page load time, response time, and resource load time; startup time is the time from application startup to full loading of the home page; page load time is the loading time of each native page, including the first screen time and full loading time; response time is the response time of the application to user operations, such as the feedback time after clicking a button; resource load time is the loading time of various resources such as images and scripts; errors and exceptions are: crash information, out of memory (OOM), stuttering, application not responding (ANR), and custom errors that occur during application operation, including error type, stack information, and occurrence time.(7) Web performance data processing includes: page load time, response time, resource load time, errors and white screen; page load time is: the load time of the embedded H5 page, including the first screen time and the full load time; response time is: the response time of the H5 page to user operations; resource load time is: the load time of resources such as images, scripts, and style sheets in the H5 page; errors and white screen are: JavaScript errors and white screen events that occur during the operation of the H5 page, including error type, row and column information and occurrence time.

[0106] Additionally, it is worth noting that in this embodiment, session data is collected using a client software development kit (SDK) and a Web JS probe.

[0107] This allows for the collection of comprehensive session data, fully recording the user's actual behavioral path and environment within the mobile application. This greatly compensates for the shortcomings of manual work order records, enabling developers to reproduce problem scenarios with high fidelity and improve troubleshooting efficiency.

[0108] Optionally, in this application embodiment, a possible implementation is provided for obtaining the association information of multi-dimensional session data by associating the identifiers between them, specifically by performing the following operations:

[0109] SA1: When the application starts, it generates a device identifier and a session identifier, associates the object identifier of the interactive object with the device identifier, and associates the session identifier with the device identifier and the user identifier.

[0110] In this embodiment of the application, when the client application starts, it generates a unique device identifier (represented by DID), supports the application to pass in the object identifier (represented by UserID) of the interactive object through the interface, associates UserID with DID to identify the unique device and object, and generates a session identifier (represented by SessionID). The SessionID is associated with the current DID and UserID to define a complete session.

[0111] SA2: When an interactive object accesses a native page, a view identifier is generated and associated with the monogram identifier.

[0112] In this embodiment of the application, when the interactive object accesses the native page, a unique view identifier (represented by ViewID) is generated, and the ViewID is associated with the current SessionID to identify the specific page where the interactive object is located.

[0113] SA3: When an interactive object performs an interactive operation on the native page, an operation identifier is generated and associated with the view identifier and the session identifier.

[0114] In this embodiment of the application, when the interactive object performs an interactive operation on the native page (e.g., clicks the onClick event), a unique operation identifier (represented by ActionID) is generated, and the ActionID is associated with the current ViewID and SessionID to accurately record every specific operation of the interactive object on the page.

[0115] SA4: When a network request occurs, a tracking identifier is generated and transmitted in the network request header, and the tracking identifier is associated with the identifier of the parent node that initiated the network request.

[0116] Among them, the parent node that initiates the interaction is the native page or an interactive operation.

[0117] In this embodiment of the application, when a network request occurs (the network request can be triggered by page loading or user operation), the corresponding ViewID or ActionID is associated with the parent node that initiated the request. At the same time, a unique trace identifier (represented by TraceID) is generated in the network request header, and the TraceID is associated with the backend link tracing system.

[0118] In this way, through the unique combination and association of the five identifiers—DID, UserID, SessionID, ViewID, ActionID, and TraceID—a comprehensive and precise connection is achieved between all experience-related data (including user identity, session, page, operation, network request, and backend link information) from front-end operations (including native applications and embedded H5 pages) to back-end service calls, constructing a complete front-end and back-end data link. This association mechanism enables the rapid tracing of complete user sessions, operational behaviors, page states, network request details, and even backend service call chains from any identifier (such as UserID or DID) when handling customer complaints, thereby achieving rapid and accurate problem localization and root cause analysis.

[0119] In this embodiment, the client collects the session view data for the current application session. Specifically, the session view data includes native view data and H5 view data, where H5 view data is the DOM change data of the embedded H5 page.

[0120] In this embodiment of the application, for the native part, the hook mechanism is used to listen for changes in the lifecycle methods of the native view, identify and trigger the timing of screenshots of the native view, and take a screenshot when the interaction action of the interactive object is triggered by the hook to obtain the native view data.

[0121] For example, the client uses a hook mechanism to listen for changes in the lifecycle methods of the native view (e.g., the display method of CALayer in iOS, and view lifecycle functions in Android) to identify and trigger the timing of taking a screenshot of the native view; at the same time, it uses hooks for user interaction operations (e.g., the sendEvent method of UIApplication in iOS, and onTouch event listeners in Android) to take screenshots when the interaction of the interactive object is triggered.

[0122] In this embodiment of the application, for the H5 part, a JavaScript probe is injected into the webpage view to listen for changes in DOM elements and MutationObserver events of the H5 page, thereby obtaining H5 view data.

[0123] For example, the client automatically injects a JavaScript probe into the WebView to listen for and record changes to DOM elements on the H5 page, while also monitoring MutationObserver events.

[0124] Optionally, in this embodiment, the native view data includes: native view data of the embedded H5 page, which includes: the location information, size information, and webpage view identifier of the embedded H5 page.

[0125] In this embodiment of the application, within the client SDK, a unique web view identifier (represented by webviewId) is assigned to each embedded WebView. When taking a screenshot of each frame, if a WebView exists in the current image, the webviewId of the WebView, as well as the WebView's position information in the native view (e.g., its position relative to the left side of the native view (represented by left), its position relative to the top of the native view (represented by top), and its size information (e.g., its width (represented by width) and height (represented by height)) are reported simultaneously. The scaling ratio of the native view is also taken into account to accurately identify and locate the area of ​​the H5 content.

[0126] See Figure 4 The figure shown is a schematic diagram of the native view of the embedded H5 page in the embodiment of this application. Figures (a)-(d) show four common cases of H5 pages being embedded in the native view.

[0127] Optionally, in this embodiment of the application, the screenshot operation is designed with anti-shake. Specifically, when a screenshot command is received, if the distance between the current time and the last screenshot time is greater than a preset minimum time interval, the screenshot operation is performed.

[0128] The preset minimum time interval can be 750 milliseconds, but this embodiment does not impose any limitation on it.

[0129] This way, the frequency of screenshots can be reduced while maintaining view continuity.

[0130] Optionally, in this embodiment of the application, after the client collects the session view data, the client compresses and controls the resolution of the session view data.

[0131] In this embodiment, the client performs efficient local compression on the collected session view data (e.g., native page screenshots) to generate a small binary file. At the same time, it supports high, medium, and low resolution settings, allowing the image size to be controlled according to network environment, device performance, or monitoring needs, further reducing resource consumption.

[0132] Optionally, in this embodiment of the application, after the client collects the session view data, it identifies and hides the privacy elements contained in the session view data according to preset privacy rules.

[0133] Privacy elements include, but are not limited to, privacy areas and privacy user interface (UI) controls. Privacy areas refer to dynamically identified sensitive areas of the interface, such as a user-drawn signature area or randomly appearing personal information in a screenshot (e.g., a phone number in a chat window). Privacy UI controls refer to preset sensitive information input components in the application interface, such as password input fields, ID number input fields, and bank card input areas.

[0134] In this embodiment, the client identifies and hides privacy elements contained in the collected session view data in real time according to preset privacy rules (e.g., fills it with a black layer) to ensure that sensitive data is not collected and uploaded.

[0135] For example, the hiding modes include: occlusion by view ID, occlusion by view object, occlusion of the entire page (Activity), occlusion of fragments, occlusion of a part of the application (APP), and occlusion of a view of a certain class.

[0136] Additionally, it is worth noting that the privacy rules in this application embodiment can be customized by the interactive object.

[0137] In this way, real-time masking of privacy elements is supported on the client side, ensuring that sensitive data is not collected and uploaded at the source, which greatly improves the compliance and security of user privacy protection.

[0138] Furthermore, after the client collects the session view data, it sends the locally stored session view data to the backend service module in batches.

[0139] In this embodiment, the client caches the compressed session view data locally in minute-by-minute chunks. Session view data compression and retrieval are performed using asynchronous threads, avoiding blocking the main thread and ensuring smooth app operation.

[0140] For example, see Figure 5 The diagram shows a flowchart of the session view data collection and storage process in this application embodiment. A screenshot command is triggered when the view changes, and when the interactive object interacts with the application (i.e., user interaction). The screenshot operation is performed when the distance between the current time and the last screenshot time is greater than a preset minimum time interval.

[0141] By employing intelligent screenshot triggering, local asynchronous compression into binary files, multi-resolution settings, and batch intelligent uploading strategies, the consumption of client CPU, memory, and network traffic is significantly reduced, while ensuring the continuity and clarity of playback, thus solving the performance and cost pain points of traditional video recording solutions.

[0142] See Figure 6 The flowchart shown is a process for recording a screenshot in an embodiment of this application, which specifically includes the following steps: S60: Start.

[0143] S61: Trigger screenshot command.

[0144] In this embodiment of the application, a screenshot command is triggered by a view refresh, user operation, or web DOM change.

[0145] S62: Determine whether the interval with the previous frame is greater than the preset minimum time interval. If yes, execute S63; otherwise, execute S610.

[0146] S63: Perform a screenshot operation.

[0147] S64: Determine if the screenshot contains private elements. If yes, execute S65; otherwise, execute S66.

[0148] S65: Hide privacy elements.

[0149] S66: Compression.

[0150] S67: Determine if there is a user operation. If yes, execute S68; otherwise, execute S69.

[0151] S68: Associate the operation with the screenshot.

[0152] S69: Write to file.

[0153] S610: One frame screenshot recorded.

[0154] In this embodiment, the client SDK's upload queue is monitored every minute, and a fixed number of data blocks are uploaded each time (e.g., one data item is uploaded each time, and the uploads are performed in a loop). Figure 7 As shown, where, Figure 7 WebP is an image file format that provides both lossy and lossless (reversible) compression. It also supports custom selection of the upload environment and strategy based on the detected network type (e.g., Wi-Fi and mobile networks), enabling batch, intelligent, and resource-efficient data uploads.

[0155] Optionally, in this embodiment, when the backend service module receives session view data uploaded by the client SDK, it parses the data according to the data protocol version and aggregates the data according to the SessionID. The backend service module sets the application type (appType) of the native view data of the embedded H5 page to a web view, distinguishing it from independent app and web types, and stores it in the database, clearly indicating that the web view data exists in relation to the native view data and cannot be played independently. A webviewSegments field is added to the backend service module's API interface (e.g., the segments interface), grouping the H5 view data according to webviewId and returning it along with the native view data, facilitating the frontend player to obtain and coordinate the playback data of the native view and the embedded H5 view. The backend service module updates the underlying data protocol (e.g., Protobuf), adding a webview_id field and a Webview structure (including fields such as id, width, height, left, and top) to support cross-platform data transmission and structured storage.

[0156] S31: Store basic session data and provide an API interface that supports multi-dimensional session data querying, so that the target object can query multi-dimensional session data through related information.

[0157] In this embodiment, the backend service module 202 stores the basic session data received from the client and provides an API interface that supports multi-dimensional session data query, so that the target object can query the basic session data through associated information. In response to the target object's query request for multi-dimensional session data, the backend service module 202 returns the corresponding multi-dimensional session data to the target object.

[0158] For example, if the object identifier carried in the query request is 001, then the multi-dimensional session data corresponding to object identifier 001 will be sent to the target object. The multi-dimensional session data includes, but is not limited to: device information associated with object identifier 001, session attribute information, operation behavior, page status, network request details, and backend service call chain.

[0159] In this way, the target object can quickly locate the session through UserID or DID, and combine multi-dimensional session data (user operations, network request details, etc.) session view data to reproduce the problem scenario in a high-fidelity visualization, which greatly shortens the troubleshooting time and thus significantly improves customer satisfaction.

[0160] In this embodiment of the application, an API interface is provided to support session view data query, so that the target object can query session view data.

[0161] For example, see Figure 8 The diagram illustrates the querying of session data in this embodiment. Basic session data is collected from various clients (e.g., mobile applications, browsers, and mini-programs). Specifically, basic session data for mobile applications is collected through the APP-Wrap layer, basic session data for browsers is collected through the Browser-Wrap layer, and basic session data for mini-programs is collected through the MP-Wrap layer. Based on UserID sharding, all data is partitioned by UserID hash and entered into a Kafka message queue, ensuring that data for the same user is routed to the same processing node. Session view data (i.e., playback data) is obtained through the Browser SDK and APP-SDK, compressed, and stored in object storage (NBFS). Data processing is performed on the basic session data and session view data, triggering alarm stream processing, such as a second-level alarm in case of a crash. Basic session data is stored in three tables: a Session Metadata Table, a Trace / Event Table, and a User Information Table. Session view data is stored in a Replay Table. The Session Metadata Table stores basic session information (e.g., session identifier, session start time), the Trace / Event Table stores tracking data such as user behavior, performance, and network activity, the User Information Table stores user profile data (e.g., object identifier, device identifier), and the Replay Table stores replay data indexes (e.g., NBFS file paths). A query engine is then used to retrieve the corresponding data. Figure 8In this code, trace / event represents tracking data, replay-message represents replay data, Kafka represents a message queue, Run-data-server represents a real-time data processing service, replay-data-receiver represents a replay data receiving service, NBFS represents an object storage system, Query Engine represents a query engine, page-data represents view data, nbfs-path represents the storage path for view data returned by NBFS, http-server represents an external HTTP server, topic:run-trace represents the topic for user experience data messages with the topic name run-trace, topic:run-replay represents the topic for view data messages with the name run-replay, and ingress represents the component name, defining which interfaces are routed to which services.

[0162] S32: Through the front-end player, based on the session view data, synchronously render the playback content of the native view and the H5 view, so that the target object can locate the abnormal problem based on the playback content.

[0163] The front-end player employs a layered rendering architecture, comprising a native view renderer and a webpage view renderer. The webpage view renderer maintains the Web player instance corresponding to the webpage view identifier. The native view renderer is an image renderer used to render native webpage screenshots, while the webpage view renderer is a WebView renderer used to render H5 content.

[0164] In this embodiment, playback is driven by the native view renderer's playback timer, and the rendering area, scaling ratio, and position of the Web player instance are dynamically adjusted according to position and size information to synchronously render the playback content of the native view and H5 view.

[0165] Specifically, during the initialization of the front-end player, each native view data is obtained through the API interface. If a native view data contains embedded H5 view data, the H5 view data grouped by webviewId is also returned. During playback, the native view renderer acts as the controller, and its playback timer drives the entire playback. For each frame of native view data, the player dynamically adjusts the scaling, position, and size of the corresponding Web player instance based on the position and size information of the embedded H5 page recorded in the native view data, and precisely and synchronously renders the corresponding H5 view data within that area. This implements complex collaborative logic between the native view renderer and the web view renderer, including time synchronization and state consistency for operations such as play, pause, and jump, ensuring that the playback content is coherent, seamless, and high-fidelity when the user switches between the native and H5 interfaces.

[0166] Furthermore, this application embodiment provides intelligent hybrid video jump logic to optimize handling situations where users jump to areas where the timelines of native view data and H5 view data do not completely overlap. Specifically, when the playback content jumps to a point where there is an H5 page container component but no H5 view data, it ensures that a webpage view renderer is created and that the timer of the webpage view renderer runs idle; when the playback content jumps to a point where there is H5 view data, it loads the H5 view data and synchronizes the player time.

[0167] This solves the problem of data gap between native and H5 pages in traditional solutions, enabling complete and coherent back of all user behaviors and content when switching between platforms, providing an unprecedented ability to accurately reconstruct the problem scene.

[0168] Optionally, in this embodiment, the backend service module can also obtain the privacy policy configuration of H5 video recording (such as privacyMode, blockClass, maskTextClass, ignoreClass, etc.) and send it to the web page view renderer to achieve unified privacy protection management.

[0169] This ensures that sensitive data is not collected or uploaded at the source, greatly improving the compliance and security of user privacy protection.

[0170] Furthermore, in this embodiment, the collected session data can be subjected to in-depth analysis, including user behavior path analysis, performance bottleneck identification, error and crash diagnosis, and the analysis results can be presented intuitively in the form of visual reports, user behavior replays, etc., to help R&D and business personnel quickly locate and resolve customer complaints.

[0171] Furthermore, based on the same technical concept, embodiments of this application provide an application backtracking device, which is used to implement the above-described method flow of embodiments of this application. For example, see [link to relevant documentation]. Figure 9 As shown, the application playback device 900 may include: an acquisition module 901, a processing module 902, and a playback module 903, wherein:

[0172] The acquisition module 901 is used to acquire the session data of the application in this session. The session data represents the set of interactive behaviors between the interactive object and the application in this time period. The session data includes: session view data and session basic data. The session view data includes: native view data and H5 view data. The session basic data includes: multi-dimensional session data and the association information of multi-dimensional session data.

[0173] Processing module 902 is used to store basic session data and provide an API interface that supports multi-dimensional session data query, so that the target object can query multi-dimensional session data through related information;

[0174] The playback module 903 is used to synchronously render the playback content of the native view and H5 view based on the session view data through the front-end player, so that the target object can locate the abnormal problem based on the playback content.

[0175] In an optional embodiment, when obtaining session data for the current session of the application, the acquisition module 901 is used to:

[0176] Through the client, multi-dimensional session data of the current session of the application is collected, and the identifiers between the multi-dimensional session data are associated to obtain the association information of the multi-dimensional session data;

[0177] Session view data is collected through the client.

[0178] In an optional embodiment, when obtaining the association information of multi-dimensional session data by associating the identifiers between the multi-dimensional session data, the acquisition module 901 is used to:

[0179] When the application starts, a device identifier and a session identifier are generated, and the object identifier of the interactive object is associated with the device identifier, and the session identifier is associated with the device identifier and the user identifier.

[0180] When an interactive object accesses a native page, a view identifier is generated and associated with a monogram identifier;

[0181] When an interactive object performs an interactive operation on the native page, an operation identifier is generated and associated with the view identifier and the session identifier;

[0182] When a network request occurs, a tracking identifier is generated and transmitted in the network request header, and the tracking identifier is associated with the identifier of the parent node that initiated the network request, where the parent node is a native page or an interactive operation.

[0183] In an optional embodiment, when collecting session view data via a client, the acquisition module 901 is used to:

[0184] By listening to changes in the lifecycle methods of the native view through a hook mechanism, the timing for taking a screenshot of the native view can be identified and triggered. The screenshot is then taken when the interaction action of the interactive object is triggered, and the native view data is obtained.

[0185] By injecting JavaScript probes into the webpage view, we can listen for changes in DOM elements and MutationObserver events on the H5 page to obtain H5 view data.

[0186] In an optional embodiment, the acquisition module 901 is used to:

[0187] When a screenshot command is received, if the distance between the current time and the last screenshot time is greater than the preset minimum time interval, the screenshot operation will be executed.

[0188] In an optional embodiment, after acquiring the session view data, the acquisition module 901 is further configured to:

[0189] Compression and resolution control of session view data are achieved through client-side processing;

[0190] Through the client, privacy elements contained in the session view data are identified and hidden according to preset privacy rules.

[0191] In one optional embodiment, the native view data includes: native view data of the embedded H5 page, which includes: location information, size information, and webpage view identifier of the embedded H5 page;

[0192] The front-end player includes a native view renderer and a web page view renderer. The web page view renderer maintains the web player instance corresponding to the web page view identifier.

[0193] In an optional embodiment, the playback module 903 is used to synchronously render the playback content of the native view and the H5 view based on the session view data through the front-end player, so that when the target object locates the abnormal problem based on the playback content, the playback module 903 is used to:

[0194] Playback is driven by the native view renderer's playback timer, and the rendering area, scaling ratio, and position of the Web player instance are dynamically adjusted based on position and size information to synchronously render the playback content of the native view and H5 view.

[0195] In an optional embodiment, the playback module 903 is further configured to:

[0196] When the playback content jumps to a point where there is an H5 page container component but no H5 view data, a web page view renderer is created and the timer of the web page view renderer is made to run in idling.

[0197] When the playback content jumps to a point in time where H5 view data is available, the H5 view data is loaded and the player time is synchronized.

[0198] Based on the description of the method and apparatus embodiments above, an exemplary embodiment of the present invention also provides an electronic device, including: at least one processor; and a memory communicatively connected to the at least one processor. The memory stores a computer program executable by the at least one processor, which, when executed by the at least one processor, causes the electronic device to perform the method according to an embodiment of the present invention.

[0199] This application also provides a non-transitory computer-readable storage medium storing a computer program, wherein the computer program, when executed by a computer's processor, is used to cause the computer to perform a method according to an embodiment of this application.

[0200] This application also provides a computer program product, including a computer program, wherein the computer program, when executed by a computer's processor, is used to cause the computer to perform a method according to an embodiment of this application.

[0201] See Figure 10 The diagram shown below illustrates a structural block diagram of an electronic device 1000 that can serve as a server or client of this application, which is an example of a hardware device that can be applied to various aspects of this application. The electronic device is intended to represent various forms of digital electronic computer devices, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device can also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the application described and / or claimed herein.

[0202] like Figure 10As shown, the electronic device 1000 includes a computing unit 1001, which can perform various appropriate actions and processes according to a computer program stored in a read-only memory (ROM) 1002 or a computer program loaded from a storage unit 1008 into a random access memory (RAM) 1003. The RAM 1003 may also store various programs and data required for the operation of the device 1000. The computing unit 1001, ROM 1002, and RAM 1003 are interconnected via a bus 1004. An input / output (I / O) interface 1005 is also connected to the bus 1004.

[0203] Multiple components in electronic device 1000 are connected to I / O interface 1005, including: input unit 1006, output unit 1007, storage unit 1008, and communication unit 1009. Input unit 1006 can be any type of device capable of inputting information to electronic device 1000. Input unit 1006 can receive input digital or character information and generate key signal inputs related to user settings and / or function control of electronic device. Output unit 1007 can be any type of device capable of presenting information and may include, but is not limited to, a display, speaker, video / audio output terminal, vibrator, and / or printer. Storage unit 1008 may include, but is not limited to, disk and optical disk. Communication unit 1009 allows electronic device 1000 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks, and may include, but is not limited to, modems, network cards, infrared communication devices, wireless communication transceivers and / or chipsets, such as Bluetooth devices, WiFi devices, worldwide interoperability for microwave access (WiMax) devices, cellular communication devices, and / or the like.

[0204] The computing unit 1001 can be various general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of the computing unit 1001 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various artificial intelligence (AI) computing chips, various computing units running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. The computing unit 1001 performs the various methods and processes described above. For example, in some embodiments, the above-described application backtracking method can be implemented as a computer software program tangibly contained in a machine-readable medium, such as storage unit 1008. In some embodiments, part or all of the computer program can be loaded and / or installed on the electronic device 1000 via ROM 1002 and / or communication unit 1009. In some embodiments, the computing unit 1001 can be configured to perform the above-described application backtracking method by any other suitable means (e.g., by means of firmware).

[0205] The program code used to implement the methods of this application may be written in any combination of one or more programming languages. This program code may be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing device, such that when executed by the processor or controller, the functions / operations specified in the flowcharts and / or block diagrams are implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0206] In the context of this application, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, RAM, ROM, erasable programmable read-only memory (EPROM) or flash memory, optical fibers, compact disc read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0207] As used in this application, the terms "machine-readable medium" and "computer-readable medium" refer to any computer program product, device, and / or apparatus (e.g., disk, optical disk, memory, programmable logic device, PLD) used to provide machine instructions and / or data to a programmable processor, including machine-readable media that receive machine instructions as machine-readable signals. The term "machine-readable signal" refers to any signal used to provide machine instructions and / or data to a programmable processor.

[0208] To provide interaction with a user, the systems and techniques described herein can be implemented on a computer having: a display device for displaying information to the user (e.g., a cathode ray tube (CRT) or liquid crystal display (LCD) monitor); and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the computer. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0209] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as data servers), or computing systems that include middleware components (e.g., application servers), or computing systems that include frontend components (e.g., user computers with graphical user interfaces or web browsers through which users can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., communication networks). Examples of communication networks include local area networks (LANs), wide area networks (WANs), and the Internet.

[0210] Computer systems can include clients and servers. Clients and servers are generally located far apart and typically interact through communication networks. Client-server relationships are created by computer programs running on the respective computers and having a client-server relationship with each other.

[0211] Furthermore, it should be understood that the above-disclosed embodiments are merely preferred embodiments of this application and should not be construed as limiting the scope of the invention. Therefore, any equivalent variations made in accordance with the claims of this invention are still within the scope of this application.

Claims

1. An application backtracking method, characterized in that, include: Acquire the session data of the application for this session. The session data represents the set of interactive behaviors between the interactive object and the application within the current time period. The session data includes: session view data and session basic data. The session view data includes: native view data and H5 view data. The native view data includes: native view data of the embedded H5 page. The native view data of the embedded H5 page includes: the location information, size information and webpage view identifier of the embedded H5 page. The session basic data includes: multi-dimensional session data and the association information of multi-dimensional session data. The acquisition of session data for the current session of the application includes: collecting multi-dimensional session data for the current session of the application through a client; generating a device identifier and a session identifier when the application starts, associating the object identifier of the interactive object with the device identifier, and associating the session identifier with the device identifier and the object identifier; generating a view identifier when the interactive object accesses a native page, and associating the view identifier with the session identifier; generating an operation identifier when the interactive object performs an interactive operation on the native page, and associating the operation identifier with the view identifier and the session identifier; and generating and transmitting a tracking identifier in the network request header when a network request occurs, and associating the tracking identifier with the identifier of the initiating parent node of the network request, wherein the initiating parent node is the native page or the interactive operation. The basic session data is stored, and an API interface is provided to support the query of the multi-dimensional session data, so that the target object can query the multi-dimensional session data through the associated information; Playback is driven by the native view renderer's playback timer. Based on the location and size information, the rendering area, scaling, and position of the Web player instance are dynamically adjusted to synchronously render the playback content of both the native view and the H5 view. This allows the target object to locate abnormal issues based on the playback content. Specifically, when the playback content jumps to a point where there is an H5 page container component but no H5 view data, a web view renderer is created, and its timer is set to idle. When the playback content jumps to a point where there is H5 view data, the H5 view data is loaded, and the player time is synchronized. The web view renderer maintains the Web player instance corresponding to the web view identifier.

2. The method as described in claim 1, characterized in that, The step of obtaining the session data for the current session of the application also includes: The client collects the session view data.

3. The method as described in claim 2, characterized in that, The process of collecting the session view data through the client includes: By listening to changes in the lifecycle methods of the native view through a hook mechanism, the timing for taking a screenshot of the native view is identified and triggered. When the interaction action of the interactive object is triggered by the hook, a screenshot is taken to obtain the native view data. By injecting JavaScript probes into the webpage view, we can listen for changes in DOM elements and MutationObserver events on the H5 page to obtain H5 view data.

4. The method as described in claim 3, characterized in that, The method further includes: When a screenshot command is received, if the distance between the current time and the last screenshot time is greater than the preset minimum time interval, the screenshot operation will be executed.

5. The method as described in claim 2, characterized in that, After collecting the session view data, the process also includes: The client performs compression and resolution control on the session view data. The client identifies and hides privacy elements contained in the session view data according to preset privacy rules.

6. An application rollback device, characterized in that, include: The acquisition module is used to acquire the session data of the application in the current session. The session data represents the set of interactive behaviors between the interactive object and the application within the current time period. The session data includes: session view data and session basic data. The session view data includes: native view data and H5 view data. The native view data includes: native view data of the embedded H5 page. The native view data of the embedded H5 page includes: the position information, size information and webpage view identifier of the embedded H5 page. The session basic data includes: multi-dimensional session data and the association information of multi-dimensional session data. The acquisition module is further configured to: collect the multi-dimensional session data of the current session of the application through the client; generate a device identifier and a session identifier when the application starts, and associate the object identifier of the interactive object with the device identifier, and associate the session identifier with the device identifier and the object identifier; generate a view identifier when the interactive object accesses the native page, and associate the view identifier with the session identifier; generate an operation identifier when the interactive object performs an interactive operation on the native page, and associate the operation identifier with the view identifier and the session identifier; and generate and transmit a tracking identifier in the network request header when a network request occurs, and associate the tracking identifier with the identifier of the initiating parent node of the network request, wherein the initiating parent node is the native page or the interactive operation. The processing module is used to store the basic session data and provide an API interface to support the query of the multi-dimensional session data, so that the target object can query the multi-dimensional session data through the associated information. The playback module is used to drive playback via the native view renderer according to the playback timer of the native view renderer, and dynamically adjust the rendering area, scaling ratio, and position of the Web player instance based on the position information and size information, synchronously rendering the playback content of the native view and the H5 view, so that the target object can locate the abnormal problem based on the playback content; wherein, when the playback content jumps to a point in time with an H5 page container component but no H5 view data, a web view renderer is created and the timer of the web view renderer is made to run idle; when the playback content jumps to a point in time with the H5 view data, the H5 view data is loaded and the player time is synchronized; the web view renderer maintains the Web player instance corresponding to the web view identifier.

7. An electronic device, comprising: processor; as well as Stored program memory, The program includes instructions that, when executed by the processor, cause the processor to perform the method as described in any one of claims 1-5.

Images