CN117540124A - Buried data generation method, system, computing device and storage medium - Google Patents

Abstract

The invention discloses a buried data generation method, a system, a computing device and a storage medium, wherein the method is executed in a framework layer and comprises the following steps: receiving a buried point event reported by a service layer, wherein the buried point event comprises an event name, an element path and user behavior data; acquiring corresponding source data based on the element path, acquiring a corresponding event object based on the event name, and acquiring reporting context data; the event processing function in the event object is operated through the safe sandbox, the returned result of the event processing function is detected in operation, and the event processing function is suitable for processing the source data, the context of the reporting adaptation module and the user behavior data to obtain the returned result; after the detection is passed, generating buried point data based on a return result of the event processing function; and reporting the buried point data to a server. The invention can improve the correctness of the embedded point data and optimize the maintainability, testability and portability of the embedded point code.

Description

Buried data generation method, system, computing device and storage medium

Technical Field

The present invention relates to the field of internet technologies, and in particular, to a buried data generating method, a buried data generating system, a computing device, and a storage medium.

Background

Currently, more and more users choose to obtain interesting information from various web pages or applications of the internet. In order to provide more accurate user services, service providers need to perform acquisition analysis on the user's behavior.

According to the prior art, one or more functions or methods are encapsulated for different types of service embedded points at a Client (Client) to process generation and reporting logic of different embedded point data, and when the embedded point data needs to be reported, user behavior data (such as behavior data of clicking screen coordinates by a user), device data, interface data (such as view rendering data) and other data are acquired and are transmitted into the functions or methods to generate and report the embedded point data. The scheme often has the following problems in the buried point working process: 1. the embedded point data reported to the server by the client has the related problems of data structures such as multiple embedded point data fields, missing report or format error when analysis is performed; 2. buried data is affected by source data, javascript is used as a cross-platform scripting language independent of an operating system, the correctness of a buried data structure cannot be ensured, and buried services cannot be safely and quickly migrated due to different client environments; 3. code for generating service embedded point data has no unified specification, so that the maintainability and portability of the code are poor.

Therefore, there is a need for a method for generating buried data to solve the above problems.

Disclosure of Invention

Accordingly, the present invention provides a buried data generating method and a buried data generating system to solve or at least alleviate the above-mentioned problems.

According to one aspect of the present invention, there is provided a buried data generating method, which is executed in a framework layer, the framework layer being communicatively connected to a service layer and a server, respectively, the method comprising: receiving a buried point event reported by a service layer, wherein the buried point event comprises an event name, an element path and user behavior data; acquiring corresponding source data based on the element path, acquiring a corresponding event object based on the event name, and acquiring reporting context data; operating an event processing function in the event object through a secure sandbox, and detecting the return result of the event processing function in the operation time, wherein the event processing function is suitable for processing the source data, the context of the reporting adaptation module and the user behavior data to obtain the return result; after the detection is passed, generating buried point data based on a return result of the event processing function; and reporting the buried point data to a server.

Optionally, in the method for generating buried data according to the present invention, the running of the event processing function in the event object by the secure sandbox and the runtime detection of the returned result of the event processing function include: judging whether the event processing function is detected in the running process; and if so, operating the event processing function in the event object through a safe sandbox, and detecting the return result of the event processing function in the operation time.

Optionally, in the method for generating buried data according to the present invention, the runtime detection of the return result of the event processing function includes: and detecting the return result of the event processing function in a running mode by using a Zod parameter method.

Optionally, in the method for generating buried data according to the present invention, further comprising: and if the event processing function is not detected in the running process, directly running the event processing function in the event object so that the event processing function processes the source data, the reporting context data and the user behavior data to obtain a return result.

Optionally, in the buried data generating method according to the present invention, the event object includes a predetermined data structure; generating buried data based on a returned result of the event processing function, including: and generating buried point data based on a return result of the event processing function according to the preset data structure.

Optionally, in the buried data generating method according to the present invention, the event processing function includes a context data processing function, a Store data processing method, a user behavior data processing method; the context data processing function is suitable for processing the reported context data to obtain a first return result; the Store data processing method is suitable for processing the source data and the reporting context data to obtain a second return result; the user behavior data processing method is suitable for operating the user behavior data to obtain a third return result.

Optionally, in the method for generating buried data according to the present invention, generating buried data based on a return result of the event processing function includes: and merging the first return result, the second return result and the third return result to obtain buried point data.

Optionally, in the method for generating buried data according to the present invention, the event object includes an event type; reporting the buried point data to a server, including: and calling a buried point reporting method corresponding to the event type, and reporting the buried point data to a server.

According to an aspect of the present invention, there is provided a buried data generating system including: a server; the client comprises a service layer, wherein the service layer is suitable for reporting a buried point event to the frame layer; the frame layer is respectively in communication connection with the service layer and the server, the frame layer comprises a buried data generating device, and the buried data generating device comprises: the receiving unit is suitable for receiving the embedded point event reported by the service layer, wherein the embedded point event comprises an event name, an element path and user behavior data; the acquisition unit is suitable for acquiring corresponding source data based on the element path, acquiring a corresponding event object based on the event name and acquiring reporting context data; the operation unit is suitable for operating an event processing function in the event object through a security sandbox and detecting the return result of the event processing function in operation, and the event processing function is suitable for processing the source data, the context of the reporting adaptation module and the user behavior data to obtain the return result; the generation unit is suitable for generating buried point data based on a return result of the event processing function after the detection is passed; and the reporting unit is suitable for reporting the buried point data to a server.

According to one aspect of the invention, there is provided a computing device comprising: at least one processor; a memory storing program instructions, wherein the program instructions are configured to be adapted to be executed by the at least one processor, the program instructions comprising instructions for performing the buried data generating method as described above.

According to an aspect of the present invention, there is provided a readable storage medium storing program instructions that, when read and executed by a computing device, cause the computing device to perform the buried data generating method as described above.

According to the method and the system for generating the embedded point data, the frame layer receives the embedded point event reported by the service layer, the embedded point event comprises an event name, an element path and user behavior data, then, corresponding metadata can be acquired based on the element path, corresponding event objects can be acquired based on the event name, and reporting context data can be acquired. And then, running an event processing function in the event object in the security sandbox, wherein the event processing function can process source data, the context of the reporting adaptation module and user behavior data to obtain a return result, detecting the return result of the event processing function in the running process by the framework layer, generating buried point data based on the return result of the event processing function after the detection is passed, and reporting the buried point data to the server. Therefore, according to the technical scheme of the invention, the buried point codes for generating the buried point data are deployed on the frame layer, so that not only is the specification of the buried point codes unified, but also the service codes and the buried point codes can be separated, and the maintainability and testability of the buried point codes can be further improved. In addition, by running the event processing function in the safe sandbox, the cross-platform portability of the embedded point code logic can be ensured, and by detecting the return result of the event processing function in the running process, the correctness of the generated embedded point data can be improved. In summary, the invention can improve the correctness of the embedded point data and optimize the maintainability, testability and portability of the embedded point code.

The foregoing description is only an overview of the present invention, and is intended to be implemented in accordance with the teachings of the present invention in order that the same may be more clearly understood and to make the same and other objects, features and advantages of the present invention more readily apparent.

Drawings

To the accomplishment of the foregoing and related ends, certain illustrative aspects are described herein in connection with the following description and the annexed drawings, which set forth the various ways in which the principles disclosed herein may be practiced, and all aspects and equivalents thereof are intended to fall within the scope of the claimed subject matter. The above, as well as additional objects, features, and advantages of the present disclosure will become more apparent from the following detailed description when read in conjunction with the accompanying drawings. Like reference numerals generally refer to like parts or elements throughout the present disclosure.

FIG. 1 shows a schematic diagram of a buried data generating system 100 according to an embodiment of the present invention;

FIG. 2 shows a schematic diagram of a computing device 200 according to one embodiment of the invention;

FIG. 3 illustrates a flow diagram of a method 300 of generating buried data according to an embodiment of the present invention.

Detailed Description

Exemplary embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be embodied in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.

In order to facilitate understanding, terms related to the present invention are explained below.

Burying: the principle is that data required during analysis is collected and analyzed in a Client (Client) according to a contracted data format, then the data is transmitted to a server, and the server analyzes and stores the data according to a contracted fixed format.

Zod: a declaration library and verification library of a schema, such as TypeScript, can make up for the problem that TypeScript cannot be verified in the runtime.

TypeScript: a superset of JavaScript may provide the ability to compile-time type checking.

Secure Sandbox (Sandbox): an execution environment that restricts program behavior in accordance with a security policy.

The buried data generation method provided by the embodiment of the invention can be implemented in a buried data generation system. The buried data generating system of the present invention is described below.

FIG. 1 shows a schematic diagram of a buried data generating system 100 according to an embodiment of the present invention.

As shown in FIG. 1, the embedded data generation system 100 includes one or more clients 110, a framework layer 120, and a server 130. Wherein client 110 includes a business layer 115, framework layer 120 may be an intermediate platform deployed between client 110 and server 130. The framework layer 120 is respectively communicatively connected to the service layer 115 and the server 130 of the client 110, for example, by a wired or wireless network connection.

The client 110 may be a terminal used by a user, specifically, a personal computer such as a desktop computer or a notebook computer, or a mobile terminal such as a mobile phone, a tablet computer, a multimedia device, or an intelligent wearable device, but is not limited thereto. Client 110 may also be an application program residing in a terminal.

The server 130 is configured to parse and store the embedded data, and may be any computing device capable of implementing data parsing and storing in the prior art, which is not limited by the specific type of the server. For example, the server 130 may be implemented as a desktop computer, a notebook computer, a processor chip, a mobile phone, a tablet computer, etc., but is not limited thereto. The server may also be a service program residing in the computing device.

In some embodiments, the client 110 may comprise a client of a JavaScript engine container, such as a browser, webView, reactNative, or the like.

In some embodiments, the business layer 115 of the client 110 may report the embedded point event to the framework layer 120. In some embodiments, the business layer 115 may also set whether to turn on runtime detection for the event handling function.

In an embodiment of the present invention, the frame layer 120 includes a buried data generating device 125, and the buried data generating device 125 includes a receiving unit 1251, an acquiring unit 1252, an operating unit 1253, a generating unit 1254, and a reporting unit 1255, which are sequentially coupled.

The receiving unit 1251 may receive a buried event reported by the service layer 115, where the buried event includes an event name, an element path, and user behavior data.

The acquisition unit 1252 may acquire corresponding source data based on the element path, acquire a corresponding event object based on the event name, and acquire reporting context data.

The operation unit 1253 may operate the event processing function in the event object through the secure sandbox, and perform runtime detection on the returned result of the event processing function, where the event processing function may process the source data, the context of the report adaptation module, and the user behavior data to obtain the returned result.

The generating unit 1254 may generate buried point data based on a return result of the event processing function after the detection passes.

The reporting unit 1255 may report the buried data to the server.

In some embodiments, the buried data generating means 125 may be implemented as an actuator. Business layer 115 may invoke an executor to report the buried point event.

In some embodiments, the frame layer 120 further comprises: report adapter, data manager, event manager, secure SandBox (SandBox). The reporting adapter may access the embedded point reporting SDKs of different host environments, define a unified calling manner for embedded point reporting methods of different event types, solve differences of calling the embedded point reporting methods in different frameworks, and may set context data (i.e., reporting context data) related to the reporting embedded point, so that the acquiring unit 1252 of the embedded point data generating apparatus 125 may acquire the reporting context data from the reporting adapter.

The data manager may be used to store source data required to generate buried point data. In some embodiments, the data manager includes a SET (setting) method and a GET (acquiring) method, where the data manager may SET data by using the SET method, store the data based on a Key-Value data structure, determine a Value type when storing the data, and store the Value reference after deep copying (opening up a new reference space) when directly storing an address reference. The data manager can acquire data by using a GET method, the entry is the Key for acquiring the data, and when the entry exists, the Value corresponding to the Key can be returned; when the Key is not entered, all data within the data manager is returned. Based on this, the acquisition unit 1252 of the buried data generating apparatus 125 may request to acquire corresponding source data from the data manager based on the element path (as Key), and the data manager may acquire source data (Value) corresponding to the element path using the GET method with the element path as an entry of the GET method and return the source data to the acquisition unit 1252 of the buried data generating apparatus 125. In other embodiments, the data manager may return all data within the data manager to the acquisition unit 1252 of the buried data generating device 125 when the element path is not incoming resulting in the absence of an entry to the GET method.

The event manager may be configured to register and manage the embedded events of the service layer 115, and obtain corresponding event objects by registering the embedded events, where the event manager may store the event objects corresponding to each embedded event. In some embodiments, the event manager may store the event name of the buried event in association with the event object such that the event manager may query and retrieve the corresponding event object based on the event name.

In some embodiments, an event name, an event ID, an event type, a predetermined data structure, an event handling function may be included in the event object.

The security sandbox can realize a JS (JavaScript) execution environment with independent execution contexts by means of the +new Function, limit accessible objects in JS codes, ensure the JS to execute in isolation, and ensure code writing specifications and buried point service mobility of a context data processing Function, a Store data processing method, a user behavior data processing method.

According to the buried point data generating system 100 provided by the embodiment of the invention, the buried point codes for generating the buried point data are deployed on the frame layer, so that not only is the specification of the buried point codes unified, but also the business codes and the buried point codes can be separated, and the maintainability and the testability of the buried point codes can be further improved. In addition, by running the event processing function in the safe sandbox, the cross-platform portability of the embedded point code logic can be ensured, and by detecting the return result of the event processing function in the running process, the correctness of the generated embedded point data can be improved. In summary, the invention can improve the correctness of the embedded point data and optimize the maintainability, testability and portability of the embedded point code.

In an embodiment of the present invention, the buried data generating method may be performed at the framework layer 120 of the buried data generating system 100. The buried data generation method 300 of the present invention will be described in detail below.

In an embodiment of the present invention, the buried data generating device 125 of the framework layer 120 may be configured to perform the buried data generating method 300 of the present invention, wherein the receiving unit 1251, the acquiring unit 1252, the operating unit 1253, the generating unit 1254, and the reporting unit 1255 may be configured to perform the steps 310 to 350, respectively, in the buried data generating method 300. Here, regarding the specific execution logic of each unit, a description of each step in the buried data generating method 300 provided in the following embodiment may be referred to.

In some embodiments, the framework layer 120 of the present invention may be implemented as a computing device such that the buried data generation method 300 of the present invention may be performed in the computing device.

FIG. 2 shows a schematic diagram of a computing device 200 according to one embodiment of the invention. As shown in FIG. 2, in a basic configuration, computing device 200 includes at least one processing unit 202 and a system memory 204. According to one aspect, the processing unit 202 may be implemented as a processor, depending on the configuration and type of computing device. The system memory 204 includes, but is not limited to, volatile storage (e.g., random access memory), non-volatile storage (e.g., read only memory), flash memory, or any combination of such memories. According to one aspect, an operating system 205 is included in system memory 204.

According to one aspect, operating system 205 is suitable for controlling the operation of computing device 200, for example. Further, examples are practiced in connection with a graphics library, other operating systems, or any other application program and are not limited to any particular application or system. This basic configuration is illustrated in fig. 2 by those components within the dashed line. According to one aspect, computing device 200 has additional features or functionality. For example, according to one aspect, computing device 200 includes additional data storage devices (removable and/or non-removable) such as, for example, magnetic disks, optical disks, or tape. Such additional storage is illustrated in fig. 2 by removable storage device 209 and non-removable storage device 210.

As set forth hereinabove, according to one aspect, program modules 203 are stored in system memory 204. According to one aspect, program module 203 may include one or more applications, the invention is not limited to the type of application, for example, the application may include: email and contacts applications, word processing applications, spreadsheet applications, database applications, slide show applications, drawing or computer-aided application, web browser applications, etc.

In an embodiment according to the present invention, program module 203 includes a plurality of program instructions for executing the buried data generating method 300 of the present invention.

According to one aspect, the examples may be practiced in a circuit comprising discrete electronic components, a packaged or integrated electronic chip containing logic gates, a circuit utilizing a microprocessor, or on a single chip containing electronic components or a microprocessor. For example, examples may be practiced via a system on a chip (SOC) in which each or many of the components shown in fig. 2 may be integrated on a single integrated circuit. According to one aspect, such SOC devices may include one or more processing units, graphics units, communication units, system virtualization units, and various application functions, all of which are integrated (or "burned") onto a chip substrate as a single integrated circuit. When operating via an SOC, the functionality described herein may be operated via dedicated logic integrated with other components of computing device 200 on a single integrated circuit (chip). Embodiments of the invention may also be practiced using other techniques capable of performing logical operations (e.g., AND, OR, AND NOT), including but NOT limited to mechanical, optical, fluidic, AND quantum techniques. In addition, embodiments of the invention may be practiced within a general purpose computer or in any other circuit or system.

According to one aspect, the computing device 200 may also have one or more input devices 212, such as a keyboard, mouse, pen, voice input device, touch input device, and the like. Output device(s) 214 such as a display, speakers, printer, etc. may also be included. The foregoing devices are examples and other devices may also be used. Computing device 200 may include one or more communication connections 216 that allow communication with other computing devices 218. Examples of suitable communication connections 216 include, but are not limited to: RF transmitter, receiver and/or transceiver circuitry; universal Serial Bus (USB), parallel and/or serial ports.

The term computer readable media as used herein includes computer storage media. Computer storage media may include volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information (e.g., computer readable instructions, data structures, or program modules). System memory 204, removable storage 209, and non-removable storage 210 are all examples of computer storage media (i.e., memory storage). Computer storage media may include Random Access Memory (RAM), read Only Memory (ROM), electrically erasable read only memory (EEPROM), flash memory or other memory technology, CD-ROM, digital Versatile Disks (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other article of manufacture that can be used to store information and that can be accessed by computing device 200. According to one aspect, any such computer storage media may be part of computing device 200. Computer storage media does not include a carrier wave or other propagated data signal.

According to one aspect, communication media is embodied by computer readable instructions, data structures, program modules, or other data in a modulated data signal (e.g., carrier wave or other transport mechanism) and includes any information delivery media. According to one aspect, the term "modulated data signal" describes a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, radio Frequency (RF), infrared, and other wireless media.

In an embodiment in accordance with the invention, computing device 200 is configured to perform a buried data generating method 300. The computing device 200 includes one or more processors and one or more readable storage media storing program instructions that, when configured to be executed by the one or more processors, cause the computing device to perform the embedded data generation method 300 in an embodiment of the invention.

In some embodiments, the computing device performing the buried data generation method 300 in embodiments of the present invention may be the framework layer 120, i.e., the buried data generation method 300 may be performed at the framework layer 120.

The buried data generation method 300 in the embodiment of the present invention is described in detail below.

FIG. 3 illustrates a flow diagram of a method 300 of generating buried data according to an embodiment of the present invention. As shown in fig. 3, the buried data generating method 300 includes the following steps 310 to 350.

In step 310, the framework layer 120 receives a buried event reported by the service layer 115, where the buried event includes an event name, an element path, and user behavior data.

In some embodiments, business layer 115 may invoke an executor to report a buried point event.

In step 320, the framework layer 120 acquires corresponding source data (source data required for generating buried point data) based on the element path, acquires corresponding event objects based on event names, and acquires reporting context data.

In some embodiments, an event name, an event ID, an event type, a predetermined data structure, an event handling function may be included in the event object. Here, the predetermined data structure may be a data structure of buried point data defined or declared in advance.

In some embodiments, the framework layer 120 may obtain corresponding source data (source data needed to generate buried point data) from the data manager based on the element path. The framework layer 120 may obtain the corresponding event object from the event manager based on the event name. And, the framework layer 120 may obtain reporting context data from the reporting adapter.

In step 330, the framework layer 120 may run event processing functions in the event object through the secure sandbox (i.e., run the event processing functions within the secure sandbox) and run-time detect the returned results of the event processing functions. The event processing function can process source data, the context of the reporting adaptation module and user behavior data in the running process so as to obtain a return result.

In some embodiments, the framework layer 120 may utilize the Zod parameter method to run-time detect the returned results of the event handling function.

In some embodiments, the framework layer 120 may first determine whether to perform runtime detection on the event processing function, and if it is determined to perform runtime detection on the event processing function, may run the event processing function in the event object through a secure sandbox, and perform runtime detection on a returned result of the event processing function. If it is determined that the event processing function is not detected during the running process, the framework layer 120 may directly run the event processing function in the event object, so that the event processing function processes the source data, the reporting context data, and the user behavior data, and obtains a return result.

In some alternative embodiments, the service layer 115 may set whether to turn on the runtime detection, and if the service layer 115 sets on the runtime detection, the framework layer 120 determines to perform the runtime detection on the event processing function, and may further run the event processing function in the event object through a secure sandbox, and perform the runtime detection on the returned result of the event processing function. On the contrary, if the service layer 115 sets the runtime detection not to be started, the framework layer 120 determines that the runtime detection is not performed on the event processing function, in which case, the framework layer 120 may directly run the event processing function in the event object, so that the event processing function processes the source data, the reporting context data, and the user behavior data, and obtains a return result.

After the run-time detection of the return result of the event handling function passes, the framework layer 120 may generate buried point data based on the return result of the event handling function in step 340.

In some embodiments, the framework layer 120 may generate buried point data based on the returned results of the event processing functions according to a predetermined data structure in the event object. In other words, the framework layer 120 may generate buried point data of a predetermined data structure based on a returned result of the event processing function.

In some embodiments, the event processing functions include a contextual data processing function, a Store data processing method, a user behavior data processing method. The context data processing function, the Store data processing method and the user behavior data processing method can respectively process and obtain a first return result, a second return result and a third return result. The framework layer 120 may combine the first return result, the second return result, and the third return result to obtain buried point data.

The context data processing function may process the acquired reporting context data to obtain a first return result. Here, the reporting context data is the entry of the context data processing function. The Store data processing method can process the acquired source data and the reported context data to obtain a second return result. Here, the source data and the reporting context data are references to the Store data processing method. The user behavior data processing method can operate the user behavior data to obtain a third return result.

In other embodiments, when the element path is not incoming, resulting in the absence of the GET method's entry, the framework layer 120 in step 320 does not obtain the source data, but rather all the data within the data manager. In this embodiment, the Store data processing method may process all the data in the data manager and the reporting context data, to obtain the second returned result.

In step 350, the framework layer 120 reports the embedded point data to the server 130.

In some embodiments, the framework layer may invoke a buried point reporting method corresponding to an event type in the event object to report buried point data to the server.

In some embodiments, the framework layer may obtain a buried point reporting method corresponding to the event type from the reporting adapter based on the event type in the event object, and report the buried point data to the server by calling the buried point reporting method corresponding to the event type.

In some embodiments, the framework layer may report the embedded point data and the corresponding event ID (the event ID may be used as an ID of the embedded point data) to the server, so that the server may store the event ID and the embedded point data in association, so as to facilitate management and query of the embedded point data, for example, may query the corresponding embedded point data based on the event ID.

According to the method 300 for generating the embedded point, the frame layer receives the embedded point event reported by the service layer, wherein the embedded point event comprises an event name, an element path and user behavior data, and then, corresponding metadata can be acquired based on the element path, corresponding event objects can be acquired based on the event name, and reporting context data can be acquired. And then, running an event processing function in the event object in the security sandbox, wherein the event processing function can process source data, the context of the reporting adaptation module and user behavior data to obtain a return result, detecting the return result of the event processing function in the running process by the framework layer, generating buried point data based on the return result of the event processing function after the detection is passed, and reporting the buried point data to the server. Therefore, according to the technical scheme of the invention, the buried point codes for generating the buried point data are deployed on the frame layer, so that not only is the specification of the buried point codes unified, but also the service codes and the buried point codes can be separated, and the maintainability and testability of the buried point codes can be further improved. In addition, by running the event processing function in the safe sandbox, the cross-platform portability of the embedded point code logic can be ensured, and by detecting the return result of the event processing function in the running process, the correctness of the generated embedded point data can be improved. In summary, the invention can improve the correctness of the embedded point data and optimize the maintainability, testability and portability of the embedded point code.

In addition, the embodiment of the invention further comprises: a8, the method of any of A1-A7, wherein the event object comprises an event type; reporting the buried point data to a server, including: and calling a buried point reporting method corresponding to the event type, and reporting the buried point data to a server.

The various techniques described herein may be implemented in connection with hardware or software or, alternatively, with a combination of both. Thus, the methods and apparatus of the present invention, or certain aspects or portions of the methods and apparatus of the present invention, may take the form of program code (i.e., instructions) embodied in tangible media, such as removable hard drives, U-drives, floppy diskettes, CD-ROMs, or any other machine-readable storage medium, wherein, when the program is loaded into and executed by a machine, such as a computer, the machine becomes an apparatus for practicing the invention.

In the case of program code execution on programmable computers, the mobile terminal will generally include a processor, a storage medium readable by the processor (including volatile and non-volatile memory and/or storage elements), at least one input device, and at least one output device. Wherein the memory is configured to store program code; the processor is configured to execute the buried data generating method of the present invention according to instructions in said program code stored in the memory.

By way of example, and not limitation, readable media comprise readable storage media and communication media. The readable storage medium stores information such as computer readable instructions, data structures, program modules, or other data. Communication media typically embodies computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media. Combinations of any of the above are also included within the scope of readable media.

In the description provided herein, algorithms and displays are not inherently related to any particular computer, virtual system, or other apparatus. Various general-purpose systems may also be used with examples of the invention. The required structure for a construction of such a system is apparent from the description above. In addition, the present invention is not directed to any particular programming language. It will be appreciated that the teachings of the present invention described herein may be implemented in a variety of programming languages, and the above description of specific languages is provided for disclosure of enablement and best mode of the present invention.

In the description provided herein, numerous specific details are set forth. However, it is understood that embodiments of the invention may be practiced without these specific details. In some instances, well-known methods, structures and techniques have not been shown in detail in order not to obscure an understanding of this description.

Similarly, it should be appreciated that in the foregoing description of exemplary embodiments of the invention, various features of the invention are sometimes grouped together in a single embodiment, figure, or description thereof for the purpose of streamlining the disclosure and aiding in the understanding of one or more of the various inventive aspects.

Those skilled in the art will appreciate that the modules or units or components of the devices in the examples disclosed herein may be arranged in a device as described in this embodiment, or alternatively may be located in one or more devices different from the devices in this example. The modules in the foregoing examples may be combined into one module or may be further divided into a plurality of sub-modules.

Unless otherwise specified the use of the ordinal adjectives "first", "second", "third", etc., to describe a common object, merely indicate that different instances of like objects are being referred to, and are not intended to imply that the objects so described must be in a given sequence, either temporally, spatially, in ranking, or in any other manner.

Claims (10)

1. A buried data generation method, executed in a framework layer, where the framework layer is respectively in communication connection with a service layer and a server, the method comprising:

receiving a buried point event reported by a service layer, wherein the buried point event comprises an event name, an element path and user behavior data;

acquiring corresponding source data based on the element path, acquiring a corresponding event object based on the event name, and acquiring reporting context data;

operating an event processing function in the event object through a secure sandbox, and detecting the return result of the event processing function in the operation time, wherein the event processing function is suitable for processing the source data, the context of the reporting adaptation module and the user behavior data to obtain the return result;

after the detection is passed, generating buried point data based on a return result of the event processing function;

and reporting the buried point data to a server.

2. The method of claim 1, wherein running an event processing function in the event object through a secure sandbox and runtime detecting a return result of the event processing function comprises:

judging whether the event processing function is detected in the running process;

and if so, operating the event processing function in the event object through a safe sandbox, and detecting the return result of the event processing function in the operation time.

3. The method of claim 1 or 2, wherein run-time detection of returned results of the event handling function comprises:

and detecting the return result of the event processing function in a running mode by using a Zod parameter method.

4. The method of claim 2, further comprising:

and if the event processing function is not detected in the running process, directly running the event processing function in the event object so that the event processing function processes the source data, the reporting context data and the user behavior data to obtain a return result.

5. The method of any of claims 1-4, wherein the event object comprises a predetermined data structure; generating buried data based on a returned result of the event processing function, including:

and generating buried point data based on a return result of the event processing function according to the preset data structure.

6. The method of any of claims 1-5, wherein the event processing function comprises a contextual data processing function, a Store data processing method, a user behavior data processing method;

the context data processing function is suitable for processing the reported context data to obtain a first return result;

the Store data processing method is suitable for processing the source data and the reporting context data to obtain a second return result;

the user behavior data processing method is suitable for operating the user behavior data to obtain a third return result.

7. The method of claim 6, wherein generating buried data based on the returned result of the event handling function comprises:

and merging the first return result, the second return result and the third return result to obtain buried point data.

8. A buried data generation system, comprising:

a server;

the client comprises a service layer, wherein the service layer is suitable for reporting a buried point event to the frame layer;

the frame layer is respectively in communication connection with the service layer and the server, the frame layer comprises a buried data generating device, and the buried data generating device comprises:

the receiving unit is suitable for receiving the embedded point event reported by the service layer, wherein the embedded point event comprises an event name, an element path and user behavior data;

the acquisition unit is suitable for acquiring corresponding source data based on the element path, acquiring a corresponding event object based on the event name and acquiring reporting context data;

the operation unit is suitable for operating an event processing function in the event object through a security sandbox and detecting the return result of the event processing function in operation, and the event processing function is suitable for processing the source data, the context of the reporting adaptation module and the user behavior data to obtain the return result;

the generation unit is suitable for generating buried point data based on a return result of the event processing function after the detection is passed;

and the reporting unit is suitable for reporting the buried point data to a server.

9. A computing device, comprising:

at least one processor; and

a memory storing program instructions, wherein the program instructions are configured to be adapted to be processed by the at least one processor, the program instructions comprising instructions for processing the method of any of claims 1-7.

10. A readable storage medium storing program instructions which, when read and processed by a computing device, cause the computing device to process the method of any of claims 1-7.