CN114595110A

CN114595110A - Point burying method, device, medium and electronic equipment for event to be monitored

Info

Publication number: CN114595110A
Application number: CN202011409605.8A
Authority: CN
Inventors: 肖翰明; 王陶; 周虎
Original assignee: Tencent Technology Shenzhen Co Ltd
Current assignee: Tencent Technology Shenzhen Co Ltd
Priority date: 2020-12-03
Filing date: 2020-12-03
Publication date: 2022-06-07

Abstract

The application provides a point burying method for an event to be monitored, a point burying device for the event to be monitored, a computer readable storage medium and an electronic device; relates to the technical field of computers; the method comprises the following steps: acquiring a plurality of types of project files for constituting the applet; extracting a target file corresponding to a specific type from a plurality of types of project files; wherein the plurality of types includes a specific type; determining a target event type meeting a preset condition from a plurality of event types included in a target file; wherein the target event type corresponds to at least one event to be monitored; and generating a buried point file according to the type of the target event, and updating the applet according to the buried point file so as to realize the monitoring of the event to be monitored when the event to be monitored is triggered. Therefore, the embedded point file can be generated according to each target event type, the small program is updated according to the embedded point file, monitoring of the event to be monitored is achieved, and embedded point efficiency is improved.

Description

Point burying method, device, medium and electronic equipment for event to be monitored

Technical Field

The present application relates to the field of computer technologies, and in particular, to a method for embedding a point for an event to be monitored, a device for embedding a point for an event to be monitored, a computer-readable storage medium, and an electronic device.

Background

If the event triggered in the program is to be monitored, a buried-point logic needs to be added to the corresponding event function, so that the monitoring operation can be executed when the event is triggered. Generally, the buried point method includes: developers manually add the buried point logic at each buried point location that is desired. However, this is prone to problems of low efficiency of spot burying and great difficulty in maintenance.

It is to be noted that the information disclosed in the above background section is only for enhancement of understanding of the background of the present application and therefore may include information that does not constitute prior art known to a person of ordinary skill in the art.

Disclosure of Invention

The present application aims to provide a point burying method for an event to be monitored, a point burying device for an event to be monitored, a computer readable storage medium and an electronic device, which can generate a point burying file according to each target event type, and update a small program according to the point burying file, so as to monitor the event to be monitored corresponding to the target event type, and improve the point burying efficiency.

Other features and advantages of the present application will be apparent from the following detailed description, or may be learned by practice of the application.

According to an aspect of the present application, there is provided a method for burying a point for an event to be monitored, including:

acquiring a plurality of types of project files for constituting the applet;

extracting a target file corresponding to a specific type from a plurality of types of project files; wherein the plurality of types includes a specific type;

determining a target event type meeting a preset condition from a plurality of event types included in a target file; wherein the target event type corresponds to at least one event to be monitored;

and generating a buried point file according to the type of the target event, and updating the applet according to the buried point file so as to realize the monitoring of the event to be monitored when the event to be monitored is triggered.

According to an aspect of the present application, there is provided a buried point device for an event to be monitored, including:

a file acquisition unit for acquiring a plurality of types of project files for constituting an applet;

a file extracting unit for extracting a target file corresponding to a specific type from a plurality of types of project files; wherein the plurality of types includes a specific type;

the event type determining unit is used for determining a target event type meeting preset conditions from a plurality of event types included in the target file; wherein the target event type corresponds to at least one event to be monitored;

the buried point file generating unit is used for generating a buried point file according to the type of the target event;

and the applet updating unit is used for updating the applet according to the embedded point file so as to realize the monitoring of the event to be monitored when the event to be monitored is triggered.

In an exemplary embodiment of the present application, the file acquiring unit acquires a plurality of types of project files for constituting an applet, including:

copying various types of project files corresponding to the small programs in a development directory;

and pasting the copied multiple types of project files to the target directory to achieve the acquisition of the multiple types of project files.

In an exemplary embodiment of the present application, the file extracting unit extracts a target file corresponding to a specific type from a plurality of types of project files, including:

determining at least one specific type corresponding to the detected user demand information;

target files corresponding to at least one specific type are extracted from a plurality of types of project files.

In an exemplary embodiment of the present application, the plurality of types of project files correspond to different file formats, and the file formats include at least one of a wxml format, a js format, and a json format.

In an exemplary embodiment of the present application, the determining, by the event type determining unit, a target event type that satisfies a preset condition from among a plurality of event types included in the target file includes:

determining type information limited by preset conditions;

the target event type is determined from a plurality of event types included in the target file according to the type information.

In an exemplary embodiment of the present application, a plurality of event types are represented by attribute names, event processing functions corresponding to the plurality of event types are represented by attribute values, and the attribute names and the attribute values are associated by a mapping relationship.

In an exemplary embodiment of the present application, the determining, by the event type determining unit, a target event type from among a plurality of event types included in the target file according to the type information includes:

and determining a target attribute name for representing the type of the target event from the target file according to the type information.

In an exemplary embodiment of the present application, if the number of the target event types is greater than 1, the generating unit of the buried point file generates the buried point file according to the target event types, including:

collecting target attribute names of all target event types to obtain a target attribute name set;

and generating a buried point file according to the target attribute name set.

In an exemplary embodiment of the present application, the applet updating unit updates the applet according to the buried point file, including:

a buried point file is added to a plurality of types of project files for constituting an applet to realize an update for the applet.

In an exemplary embodiment of the present application, the apparatus further includes:

the parameter receiving unit is used for receiving the parameters returned by all functions in the updated small program when the updated small program is executed after the small program updating unit updates the small program according to the embedded point file; wherein the function comprises an event handling function;

and the embedded point unit is used for intercepting the parameters and executing embedded point operation when the parameters are matched with any target attribute name in the embedded point file.

the matching unit is used for determining a specific attribute value corresponding to the parameter before the embedded point unit intercepts the parameter and executes the embedded point operation; matching a specific attribute name corresponding to the specific attribute value in the mapping relation; and if the matching is successful, judging that the parameters are matched with any target attribute name in the embedded point file.

In an exemplary embodiment of the present application, the fixed point unit intercepts the parameter and performs a fixed point operation, including:

intercepting parameters and executing a point burying operation by an interception function;

and monitoring the event to be monitored corresponding to the specific event processing function when at least one specific event processing function corresponding to the specific attribute value is executed.

According to an aspect of the present application, there is provided an electronic device including: a processor; and a memory for storing executable instructions for the processor; wherein the processor is configured to perform the method of any of the above via execution of the executable instructions.

According to an aspect of the application, there is provided a computer-readable storage medium having stored thereon a computer program which, when executed by a processor, implements the method of any one of the above.

According to an aspect of the application, a computer program product or computer program is provided, comprising computer instructions stored in a computer readable storage medium. The processor of the computer device reads the computer instructions from the computer-readable storage medium, and the processor executes the computer instructions to cause the computer device to perform the method provided in the various alternative implementations described above.

The exemplary embodiments of the present application may have some or all of the following advantages:

in the method for embedding the event to be monitored provided by an example embodiment of the application, a plurality of types of project files for constituting the applet can be acquired; extracting a target file corresponding to a specific type from a plurality of types of project files; wherein the plurality of types includes a specific type; determining a target event type meeting a preset condition from a plurality of event types included in a target file; wherein the target event type corresponds to at least one event to be monitored; and generating a buried point file according to the type of the target event, and updating the small program according to the buried point file so as to realize the monitoring of the event to be monitored when the event to be monitored is triggered. According to the technical description, on one hand, the embedded point file can be generated according to each target event type, and the small program is updated according to the embedded point file, so that the monitoring of the event to be monitored corresponding to the target event type is realized, and the embedded point efficiency is improved. According to the method and the device, the cost of the embedded point can be reduced, and the difficulty in realizing event monitoring is reduced.

It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the application.

Drawings

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present application and together with the description, serve to explain the principles of the application. It is obvious that the drawings in the following description are only some embodiments of the application, and that for a person skilled in the art, other drawings can be derived from them without inventive effort.

Fig. 1 is a schematic diagram illustrating an exemplary system architecture of a point burying method for an event to be monitored and a point burying device for the event to be monitored, to which an embodiment of the present application may be applied;

FIG. 2 illustrates a schematic structural diagram of a computer system suitable for use in implementing an electronic device of an embodiment of the present application;

FIG. 3 schematically illustrates a flow diagram of a method of burial of points for an event to be snooped, according to one embodiment of the present application;

FIG. 4 schematically illustrates a flow diagram for generating a buried point file according to a target event type according to one embodiment of the present application;

FIG. 5 schematically illustrates a flow chart for performing a buried point operation according to one embodiment of the present application;

FIG. 6 schematically illustrates a flow diagram of a method of burying points for an event to be listened to, according to one embodiment of the present application;

FIG. 7 schematically illustrates a flow diagram of a method of burial of points for an event to be snooped, according to another embodiment of the present application;

FIG. 8 schematically illustrates a flow diagram of a method of burial of points for an event to be snooped, according to yet another embodiment of the present application;

fig. 9 schematically shows a block diagram of a buried point device for an event to be listened to in an embodiment according to the present application.

Detailed Description

Example embodiments will now be described more fully with reference to the accompanying drawings. Example embodiments may, however, be embodied in many different forms and should not be construed as limited to the examples set forth herein; rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the concept of example embodiments to those skilled in the art. The described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments. In the following description, numerous specific details are provided to give a thorough understanding of embodiments of the application. One skilled in the relevant art will recognize, however, that the subject matter of the present application can be practiced without one or more of the specific details, or with other methods, components, devices, steps, and so forth. In other instances, well-known technical solutions have not been shown or described in detail to avoid obscuring aspects of the present application.

Furthermore, the drawings are merely schematic illustrations of the present application and are not necessarily drawn to scale. The same reference numerals in the drawings denote the same or similar parts, and thus their repetitive description will be omitted. Some of the block diagrams shown in the figures are functional entities and do not necessarily correspond to physically or logically separate entities. These functional entities may be implemented in the form of software, or in one or more hardware modules or integrated circuits, or in different networks and/or processor devices and/or microcontroller devices.

Fig. 1 is a schematic diagram illustrating a system architecture of an exemplary application environment to which a point burying method for an event to be monitored and a point burying device for the event to be monitored according to an embodiment of the present application may be applied.

As shown in fig. 1, the system architecture 100 may include one or more of

terminal devices

101, 102, 103, a network 104, and a server 105. The network 104 serves as a medium for providing communication links between the

terminal devices

101, 102, 103 and the server 105. Network 104 may include various connection types, such as wired, wireless communication links, or fiber optic cables, to name a few. The

terminal devices

101, 102, 103 may be various electronic devices having a display screen, including but not limited to desktop computers, portable computers, smart phones, tablet computers, and the like. It should be understood that the number of terminal devices, networks, and servers in fig. 1 is merely illustrative. There may be any number of terminal devices, networks, and servers, as desired for implementation. For example, server 105 may be a server cluster comprised of multiple servers, or the like.

The embedded point method for the event to be monitored provided by the embodiment of the present application is generally performed by the server 105, and accordingly, the embedded point device for the event to be monitored is generally disposed in the server 105. However, it is easily understood by those skilled in the art that the method for burying a to-be-monitored event provided in the embodiment of the present application may also be executed by the

terminal device

101, 102, or 103, and accordingly, the device for burying a to-be-monitored event may also be disposed in the

terminal device

101, 102, or 103, which is not particularly limited in this exemplary embodiment. For example, in one exemplary embodiment, the server 105 may obtain multiple types of project files for composing an applet; extracting a target file corresponding to a specific type from a plurality of types of project files; wherein the plurality of types includes a specific type; determining a target event type meeting a preset condition from a plurality of event types included in a target file; wherein the target event type corresponds to at least one event to be monitored; and generating a buried point file according to the type of the target event, and updating the applet according to the buried point file so as to realize the monitoring of the event to be monitored when the event to be monitored is triggered.

FIG. 2 illustrates a schematic structural diagram of a computer system suitable for use in implementing the electronic device of an embodiment of the present application.

It should be noted that the computer system 200 of the electronic device shown in fig. 2 is only an example, and should not bring any limitation to the functions and the scope of use of the embodiments of the present application.

As shown in fig. 2, the computer system 200 includes a Central Processing Unit (CPU)201 that can perform various appropriate actions and processes in accordance with a program stored in a Read Only Memory (ROM)202 or a program loaded from a storage section 208 into a Random Access Memory (RAM) 203. In the RAM 203, various programs and data necessary for system operation are also stored. The CPU 201, ROM 202, and RAM 203 are connected to each other via a bus 204. An input/output (I/O) interface 205 is also connected to bus 204.

The following components are connected to the I/O interface 205: an input portion 206 including a keyboard, a mouse, and the like; an output section 207 including a display such as a Cathode Ray Tube (CRT), a Liquid Crystal Display (LCD), and the like, and a speaker; a storage section 208 including a hard disk and the like; and a communication section 209 including a network interface card such as a LAN card, a modem, or the like. The communication section 209 performs communication processing via a network such as the internet. A drive 210 is also connected to the I/O interface 205 as needed. A removable medium 211, such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, or the like, is mounted on the drive 210 as necessary, so that a computer program read out therefrom is installed into the storage section 208 as necessary.

In particular, according to embodiments of the present application, the processes described below with reference to the flowcharts may be implemented as computer software programs. For example, embodiments of the present application include a computer program product comprising a computer program embodied on a computer readable medium, the computer program comprising program code for performing the method illustrated by the flow chart. In such an embodiment, the computer program may be downloaded and installed from a network through the communication section 209 and/or installed from the removable medium 211. The computer program, when executed by a Central Processing Unit (CPU)201, performs various functions defined in the methods and apparatus of the present application.

With the gradual development of small programs, the number of users is more and more. In order to analyze the situation that the user uses the small program, the small program needs to be subjected to embedded point processing. Due to the frame limitation of the applet, the monitoring processing of the operation events (such as clicking, sliding and the like) in the page can not be carried out globally. Therefore, developers need to add the buried node logic to each event processing function of each page, which is prone to the problem of high development and maintenance costs.

In addition, the method for adding page burial points for the applet can further comprise the following steps: the life cycle callback function in the page is directly monitored by accessing the third-party library, but only the event function defined by the third-party library can be monitored, so that the problem of low monitoring freedom degree easily exists. Alternatively, the developer reconstructs the applet and specifies the event processing function name to realize the embedding of the specific event function, but this also easily causes a problem of high development cost.

The present example embodiment provides a method of burying a point for an event to be listened to. The method for burying the to-be-monitored event may be applied to the server 105, and may also be applied to one or more of the

terminal devices

101, 102, and 103, which is not particularly limited in this exemplary embodiment. Referring to fig. 3, the method for burying a to-be-listened-to event may include the following steps S310 to S340.

Step S310: a plurality of types of project files for constituting an applet are acquired.

Step S320: extracting a target file corresponding to a specific type from a plurality of types of project files; wherein the plurality of types includes a specific type.

Step S330: determining a target event type meeting a preset condition from a plurality of event types included in a target file; wherein the target event type corresponds to at least one event to be listened to.

Step S340: and generating a buried point file according to the type of the target event, and updating the applet according to the buried point file so as to realize the monitoring of the event to be monitored when the event to be monitored is triggered.

The method and the device can be applied to social software applets to monitor the user behavior so as to perform effective user behavior analysis.

By implementing the method shown in fig. 3, a buried point file can be generated according to each target event type, and an applet is updated according to the buried point file, so that monitoring of the event to be monitored corresponding to the target event type is realized, and the efficiency of the buried point is improved. In addition, the cost of the embedded point can be reduced, and the difficulty in realizing event monitoring is reduced.

The above steps of the present exemplary embodiment will be described in more detail below.

In step S310, a plurality of types of project files for constituting an applet are acquired.

Specifically, the number of the plurality of types of project files used to constitute the applet may be one or more, and the embodiment of the present application is not limited. In addition, the plurality of types of project files correspond to different file formats, and the file formats include at least one of a wxml format, a js format, and a json format. Wherein wxml (WeiXin Markup language) is a set of label languages designed by a framework, and a structure of a page can be constructed by combining a basic component and an event system; the js-formatted project file is written by a JavaScript language, and the JavaScript is a lightweight programming language and is a programming code which can be inserted into an HTML page; json (JavaScript Object Notation) is a lightweight data exchange format.

Optionally, before step S310, the method may further include: configuring various types of project files through a packaging tool so as to convert languages corresponding to the various types of project files into recognizable uniform type languages; the packing tool can be a module packer (webpack module), the webpack is a static module packer of a JavaScript applet, when the webpack processes the applet, a dependency graph can be recursively constructed, each module required by the applet is contained in the dependency graph, all the modules are packed into one or more bundle files, and the bundle is an executable file in a Unix/linux operating system. Further, before configuring the plurality of types of project files through the packaging tool, it may include: and installing the webpack module and downloading the corresponding dependence of the webpack module.

Furthermore, loading data corresponding to various types of project files through a data loading tool (such as a Loader module); the Loader is used for realizing data exchange and file exchange between the system and the database. Specifically, the Loader module may include an interactive interface, a server and an interface for processing a client request and managing a connector and metadata, a job scheduling module for supporting a periodic job execution, a data conversion processing engine for supporting field merging, string cutting and string reverse order, a job execution engine, a job submission engine, a job management module for creating a job, querying a job, updating a job, deleting a job, activating a job, deactivating a job, starting a job, and stopping a job, a metadata repository, and a master/slave state for managing a Loader service process.

As an alternative embodiment, acquiring a plurality of types of project files for constituting an applet includes: copying various types of project files corresponding to the small programs in a development directory; and pasting the copied multiple types of project files to the target directory to achieve the acquisition of the multiple types of project files.

Specifically, the target catalog exists independently of the development catalog. The method for copying the multiple types of project files corresponding to the small programs in the development directory and pasting the copied multiple types of project files to the target directory comprises the following steps: and copying various types of project files corresponding to the small programs in the development directory into the target directory through the copy-webpack-plugin. Wherein the copy-webpack-plugin is used for copying files.

Therefore, by implementing the optional embodiment, multiple types of project files in the development directory can be copied to the target directory, so that the specific types of target files in the project files can be extracted, the generation of the buried point files is realized, and the buried point efficiency can be improved by applying the buried point files.

In step S320, a target file corresponding to a specific type is extracted from a plurality of types of project files; wherein the plurality of types includes a specific type.

Specifically, the number of the specific types may be one or more, and alternatively, the target file of the specific type may be a project file in wxml format. Wherein, extracting the target file corresponding to the specific type from the plurality of types of project files comprises: and extracting wxml format target files from various types of project files through a customized webpack plug-in (such as webpack plugin). The webpack plugin can monitor each event processing function in a project file in a wxml format in the process of webpack running processing, so that a task with a wider range can be executed; wherein an event handling function is a function that is called in response to a certain event.

As an alternative embodiment, extracting a target file corresponding to a specific type from a plurality of types of project files includes: determining at least one specific type corresponding to the detected user demand information; target files corresponding to at least one specific type are extracted from a plurality of types of project files.

Specifically, determining at least one specific type corresponding to the detected user requirement information includes: receiving user configuration operation and collecting user requirement information corresponding to the user configuration operation, and further determining at least one specific type corresponding to the detected user requirement information.

Therefore, the implementation of the optional embodiment can be realized according to the specific type corresponding to the monitoring requirement of the developer, so that the generation of the embedded point file according to the specific type is facilitated, and the monitoring of the event corresponding to the specific type is facilitated when the applet runs.

As an alternative embodiment, determining a target event type satisfying a preset condition from a plurality of event types included in a target file includes: determining type information limited by preset conditions; the target event type is determined from a plurality of event types included in the target file according to the type information.

Specifically, the preset condition is used to define an event type corresponding to the event to be monitored, and the type information may include a specific event to be monitored.

Therefore, by implementing the optional embodiment, the type corresponding to the event needing to be monitored can be determined according to the preset condition set by the developer, so that the implementation of targeted event monitoring is facilitated.

In step S330, a target event type satisfying a preset condition is determined from among a plurality of event types included in the target file; wherein the target event type corresponds to at least one event to be listened to.

Specifically, the target event type corresponds to at least one event to be monitored, and it is also understood that the target event type corresponds to at least one event handling function, and the target event type may include: at least one of a click event (tap), a long press event (longtap), a touch start (touchstart), a touch end (touchend), and a touch cancel (touchcancel). In addition, the multiple event types are represented by attribute names, the event processing functions corresponding to the multiple event types are represented by attribute values, and the attribute names and the attribute values are associated by a mapping relation.

As an alternative embodiment, determining the target event type from the plurality of event types included in the target file according to the type information includes: and determining a target attribute name for representing the type of the target event from the target file according to the type information.

Specifically, determining a target attribute name for representing a target event type from a target file according to the type information includes: determining a target attribute value satisfying a preset condition through a plug-in (e.g., htmlparser2) for parsing the tag and extracting the attribute value in the tag, the target attribute value belonging to the type information; further determining a target attribute value corresponding to the target attribute value according to the mapping relation between the attribute value (value) and the attribute name (key); the target attribute value corresponds to a target event processing function, the target event processing function corresponds to a target event type, and the target event type corresponds to a target attribute name.

Therefore, by implementing the optional embodiment, the target attribute name corresponding to the target event type to be monitored can be determined through the type information so as to detect the target attribute name, and once the event corresponding to the target attribute name is triggered, the point burying operation is executed, so that the automation degree of the point burying can be improved.

In step S340, a buried point file is generated according to the type of the target event, and the applet is updated according to the buried point file, so that monitoring of the event to be monitored is realized when the event to be monitored is triggered.

Specifically, the buried point file may be a file in an events. Optionally, the buried point file is further used to record a relationship between a target event type and an event processing function, and the embodiment of the present application is not limited. Wherein, according to the little program of buried point file update, include: the embedded point file is written into a global function (such as a Page function) of the small program according to webpack plugin, and the small program is updated through rewriting of the global function. The Page function is used for registering a Page in the applet and accepting the Object type parameter.

Referring to fig. 4 as an alternative embodiment, fig. 4 schematically illustrates a flowchart of generating a buried point file according to a target event type according to an embodiment of the present application. As shown in fig. 4, if the number of the target event types is greater than 1, generating a buried point file according to the target event types, the flowchart may include the following steps:

step S410: and loading various types of project files corresponding to the small programs.

Step S420: and loading data corresponding to various types of project files through the Loader.

Step S430: and generating a buried point file through webpack plugin.

Step S440: a buried point file in events.

Wherein, step S430 may include:

step S4300: copying various types of project files corresponding to the small programs in a development catalog; and pasting the copied multiple types of project files to the target directory. Step S4302: and importing various types of project files. Step S4304: detecting whether a suffix of the project file is wxml; if yes, go to step S4306; if not, the flow ends. Step S4306: a target attribute value satisfying a preset condition is determined by htmlparser2 for parsing the tag and extracting the attribute value in the tag, the target attribute value belonging to the type information. Step S4308: generating a buried point file in events.

Specifically, the manner of generating the buried point file in events. Collecting target attribute names of all target event types to obtain a target attribute name set; and generating a buried point file according to the target attribute name set.

And if the number of the target event types is greater than 1, the number of the target event processing functions is greater than 1. Before generating the buried point file according to the target attribute name set, the method further comprises the following steps: sorting each target attribute name in the target attribute name set according to the type of the target attribute name, wherein the target attribute names belonging to the same type are adjacent in the sorting result; or, sorting the target attribute names in the target attribute name set according to the sequence of the importance corresponding to the target attribute names from high to low.

Therefore, by implementing the alternative embodiment, the buried point file can be generated through the target attribute name set, so that the buried point operation can be automatically executed in the applet through the buried point file, and the automatic monitoring of the event is realized.

As an alternative embodiment, the applet is updated according to the buried point file, including: a buried point file is added to a plurality of types of project files for constituting an applet to realize an update for the applet.

Specifically, the embedded point file in the updated applet includes an embedded point function, which is used to detect whether an attribute name corresponding to a target event type is triggered in the applet executing process, when the attribute name is triggered, the embedded point function can be performed at the executing position to monitor an event to be monitored corresponding to the target event type, and the event to be monitored occurs based on the execution of the target event processing function.

It can be seen that implementing this alternative embodiment enables all processing event functions for which a buried point is desired to be collected without modifying the page code, which facilitates automatic execution of the buried point logic upon event triggering. Furthermore, the service logic and the buried point logic can be separated, so that the maintenance cost of the code is improved, and the maintenance difficulty of the code is reduced.

Referring to fig. 5 as an alternative embodiment, fig. 5 schematically illustrates a flow chart for performing a spot burying operation according to an embodiment of the present application. As shown in fig. 5, the following steps may be included:

step S510: a buried point file in events.

Step S520: and writing the buried point file into a Page function of the applet according to the webpack plugin so as to realize the update of the applet.

Step S530: a Page function is executed to register the applet Page.

Wherein, step S530 may include:

after the applet is updated from the buried point file, when the updated applet is executed, step S5300: receiving parameters returned by all functions in the updated applet; wherein the function comprises an event handling function. Further, step S5302 is executed: detecting whether any target attribute name is matched with the parameters in the buried point file in the events. If so, perform step S5304; if not, step S5300 is performed. Step S5304: intercepting parameters and executing a buried point operation.

Specifically, the embedded point is a common data acquisition method for website analysis, and the specific way of executing the embedded point operation may be as follows: executing a buried point logic corresponding to the buried point function to realize the monitoring of the event to be monitored; the monitoring of the event to be monitored is realized by acquiring a result returned by the event to be monitored.

The parameters may specifically include: page initial data (data) of type Object; a lifecycle Function (onLoad) for listening page loading, a lifecycle Function (onReady) for listening page initial rendering completion, a lifecycle Function (onShow) for listening page display, a lifecycle Function (onHide) for listening page hiding, a lifecycle Function (onUnload) for listening page unloading, a page-related event handling Function (onpulldown refresh) for listening user pull-down actions, etc., of type Function.

Therefore, by implementing the optional embodiment, the parameters returned by the function can be sequentially compared through the target attribute names in the embedded point file, and if the comparison result shows that the parameters are matched with each other, the interception logic can be executed.

As an alternative embodiment, before intercepting the parameter and performing the fixed point operation, the method further includes: determining a specific attribute value corresponding to the parameter; matching a specific attribute name corresponding to the specific attribute value in the mapping relation; and if the matching is successful, judging that the parameters are matched with any target attribute name in the embedded point file.

Under the condition of successful matching, the specific attribute value corresponding to the parameter can be a certain attribute value in the target attribute values, and the specific attribute name belongs to a target attribute name set in the buried point file. Determining a specific attribute value corresponding to the parameter, including: and determining the specific attribute value corresponding to the parameter according to the webpack plugin or Loader. In addition, the event type and the event processing function are stored as an attribute name and an attribute value, respectively, and the attribute name and the attribute value are expressed in the form of tags.

Therefore, by implementing the optional embodiment, the mapping relation matching can be performed on the specific attribute values corresponding to the parameters, so that the automatic point burying is facilitated.

As an alternative embodiment, intercepting the parameters and performing a fixed point operation includes: intercepting parameters and executing a point burying operation by an interception function; and monitoring the event to be monitored corresponding to the specific event processing function when at least one specific event processing function corresponding to the specific attribute value is executed.

In particular, the intercept function (e.g., Proxy) is used to filter and rewrite access to the outside world. In addition, monitoring the event to be monitored corresponding to the specific event processing function includes: and recording log data generated in the execution process of the specific event processing function so as to realize the monitoring of the event to be monitored. For example, the event to be monitored can be a page jump event, a page rendering event, and the like, and a page pull-down event.

In addition, optionally, after performing the burial point operation, the method may further include: acquiring user behavior data according to the small program after the point is buried; drawing user behavior distribution based on a time axis according to the user behavior data, wherein the granularity corresponding to the time axis can be time (such as 3:30, 4:30 and the like) or time period (such as 3: 00-4: 00, 4: 00-5: 00 and the like); determining a hot use time period corresponding to the small program according to the user behavior distribution; when the time reaches the hot use time slot, the advertisement is pushed so as to improve the exposure rate and the conversion rate of the advertisement.

Specifically, the manner of collecting the user behavior data according to the applet after the point burying may specifically be: user behavior data is collected by the instrumented applet over a predetermined time period (e.g., the first quarter). In addition, specifically, the manner of determining the hot use period corresponding to the applet according to the user behavior distribution may specifically be: and determining the time period when the user behavior distribution density is greater than the preset density as the hot use time period. In addition, in particular, the way of pushing the advertisement when the time reaches the hot use period may be specifically: when the time reaches the hot use time period, directionally pushing advertisements matched with the user portrait according to the user portrait corresponding to each user; the user representation is used to describe the user by attribute tags (e.g., male, middle age, bald).

Therefore, by implementing the optional embodiment, the corresponding function can be executed, and the event corresponding to the function is monitored, which is beneficial to analyzing the user behavior through the monitoring result.

It should be noted that the embodiment of the present application may be applied to any applet, the applet is generally developed by using three technologies, namely JavaScript, WXML, and WXSS, the applet is essentially a single-page application, and all page rendering and event processing in the applet can be performed in one page. The architecture of the application program as the parent program is a data-driven architecture mode, and page updating in the application program needs to be realized by changing data. The applet may call a native interface (API) of the application.

When a user triggers an application (e.g., a social-type application) to launch, the application may be launched in response to the triggering operation. An applet (e.g., a search engine applet) in the application may be launched if a user action is detected that triggers the launch of the applet. Furthermore, if the keyword input event in the applet is detected to be triggered, a point burying operation can be executed to monitor the keyword input by the user. Further, keywords input by the user each time the applet search function is used may be obtained, so that the user behavior may be analyzed according to the keywords input by the user each time.

In addition, before starting the applet, a plurality of types of project files for the applet configuration may be acquired, at least one specific type corresponding to the detected user demand information may be determined, and a target file corresponding to the at least one specific type may be extracted from the plurality of types of project files. Furthermore, type information defined by preset conditions can be determined, and a target attribute name used for representing the type of the target event can be determined from the target file according to the type information. Furthermore, the target attribute names of the target event types can be collected to obtain a target attribute name set, a buried point file is generated according to the target attribute name set, the buried point file is added into various types of project files for forming the applet, so that the applet can be updated, and the updated applet can execute a buried point operation when the file type corresponding to the attribute name in the buried point file is triggered so as to monitor the event corresponding to the file type.

Referring to fig. 6, fig. 6 schematically illustrates a flow chart of a method for burying a point for an event to be listened to according to an embodiment of the present application. As shown in fig. 6, the method for burying a point for an event to be monitored includes: step S600 to step S660.

Step S600: and copying various types of project files corresponding to the small programs in the development catalog, and pasting the copied various types of project files to the target catalog to acquire the various types of project files.

Step S610: and determining at least one specific type corresponding to the detected user requirement information, and extracting a target file corresponding to the at least one specific type from the plurality of types of project files.

Step S620: determining type information defined by preset conditions, and determining a target attribute name for representing the type of the target event from the target file according to the type information.

Step S630: and acquiring the target attribute names of all target event types to obtain a target attribute name set, and generating the buried point file according to the target attribute name set.

Step S640: a buried point file is added to a plurality of types of project files for constituting an applet to realize an update for the applet.

Step S650: when the updated applet is executed, receiving parameters returned by all functions in the updated applet; wherein the function comprises an event handling function.

Step S660: and determining a specific attribute value corresponding to the parameter, matching a specific attribute name corresponding to the specific attribute value in the mapping relation, intercepting the parameter by an interception function and executing a point burying operation if the matching is successful, and monitoring the event to be monitored corresponding to the specific event processing function when at least one specific event processing function corresponding to the specific attribute value is executed.

It should be noted that steps S600 to S660 correspond to the steps and embodiments shown in fig. 3, and for the specific implementation of steps S600 to S660, please refer to the steps and embodiments shown in fig. 3, which is not described herein again.

Therefore, by implementing the method shown in fig. 6, a buried point file can be generated according to each target event type, and an applet is updated according to the buried point file, so that monitoring of the event to be monitored corresponding to the target event type is realized, and the efficiency of the buried point is improved. In addition, the cost of the embedded point can be reduced, and the difficulty in realizing event monitoring is reduced.

Referring to fig. 7, fig. 7 schematically illustrates a flow chart of a method for burying a point for an event to be listened to according to another embodiment of the present application. As shown in fig. 7, the method of burying a point for an event to be listened to may include:

step S710: and loading various types of project files corresponding to the small programs. Step S720: and loading data corresponding to various types of project files through the Loader. Step S730: and generating a buried point file through webpack plugin. Step S740: a buried point file in events. Step S750: and writing the buried point file into a Page function of the applet according to the webpack plugin so as to realize the update of the applet. Step S760: a Page function is executed to register the applet Page.

Wherein, step S730 may include:

step S7300: copying various types of project files corresponding to the small programs in a development directory; and pasting the copied multiple types of project files to the target directory. Step S7302: and importing various types of project files. Step S7304: detecting whether the suffix of the project file is wxml; if so, perform step S7306; if not, the flow ends. Step S7306: the target attribute value satisfying the preset condition is determined by htmlparser2 for parsing the tag and extracting the attribute value in the tag, and the target attribute value belongs to the type information. Step S7308: generating a buried point file in events.

Wherein, step S760 may include:

after updating the applet according to the buried point file, when the updated applet is executed, step S7600: receiving parameters returned by all functions in the updated applet; wherein the function comprises an event handling function. Further, step S7602 is executed: detecting whether any target attribute name is matched with the parameters in the buried point file in the events. If so, go to step S7604; if not, go to step S7600. Step S7604: intercepting parameters and executing a buried point operation.

Therefore, the method and the device can monitor the whole webpack flow and the characteristic of the small program framework registration page by using the webpack plugin, and realize automatic point burying. The user-defined plug-in can be released as a third-party plug-in, the embedded point processing can be carried out on the event processing functions in all pages without changing a small program project by simply configuring the webpack and introducing the plug-in and setting corresponding parameters according to needs, and the development cost can be saved.

Referring to fig. 8, fig. 8 schematically illustrates a flow chart of a method for burying a point for an event to be listened to according to yet another embodiment of the present application. As shown in fig. 8, the method of burying a point for an event to be listened to may include:

step S810: and loading various types of project files corresponding to the small programs. Step S820: and loading data corresponding to various types of project files through the Loader. Step S830: and generating a buried point file through webpack plugin. Step S840: a buried point file in events. Step S850: and writing the buried point file into a Page function of the applet according to the webpack plugin so as to realize the update of the applet.

Furthermore, when the Page function registration applet Page is executed, the set interaction location (for example, HandleA, HandleB, onClickA, etc.) can be doted in the applet item according to the dotting file in events. And receiving parameters returned by all functions in the updated applet, if any target attribute name exists in the embedded point file in the events. Further, when handler a, handler b, onClickA, etc. are triggered during the applet page running, step S870 may be performed: and executing the self-defined buried point function.

Further, in the present exemplary embodiment, a buried point device for an event to be monitored is also provided. Referring to fig. 9, the buried point device 900 for the event to be listened to may include:

a file acquiring unit 901 for acquiring a plurality of types of project files for constituting an applet.

A file extracting unit 902 for extracting a target file corresponding to a specific type from a plurality of types of project files; wherein the plurality of types includes a specific type.

An event type determining unit 903, configured to determine a target event type that meets a preset condition from multiple event types included in the target file; wherein the target event type corresponds to at least one event to be monitored.

And a buried point file generating unit 904, configured to generate a buried point file according to the target event type.

And the applet updating unit 905 is configured to update the applet according to the buried point file, so that the monitoring of the event to be monitored is realized when the event to be monitored is triggered.

Therefore, by implementing the device shown in fig. 9, a buried point file can be generated according to each target event type, and an applet can be updated according to the buried point file, so that monitoring of an event to be monitored corresponding to the target event type is realized, and the efficiency of the buried point is improved. In addition, the cost of the embedded point can be reduced, and the difficulty in realizing event monitoring is reduced.

In an exemplary embodiment of the present application, the file acquiring unit 901 acquires a plurality of types of project files for constituting an applet, including:

In an exemplary embodiment of the present application, the file extracting unit 902 extracts a target file corresponding to a specific type from a plurality of types of project files, including:

The multiple types of project files correspond to different file formats, and the file formats comprise at least one of wxml format, js format and json format.

In an exemplary embodiment of the present application, the determining unit 903 of the event type determines a target event type satisfying a preset condition from a plurality of event types included in the target file, including:

determining type information limited by preset conditions;

The event processing function corresponding to each event type is represented by an attribute value, and the attribute names and the attribute values are associated by a mapping relation.

In an exemplary embodiment of the present application, the event type determining unit 903 determines a target event type from a plurality of event types included in the target file according to the type information, including:

Therefore, by implementing the optional embodiment, the target attribute name corresponding to the target event type to be monitored can be determined through the type information so as to detect the target attribute name, and once the event corresponding to the target attribute name is triggered, the embedded point operation is executed, so that the embedded point automation degree can be improved.

In an exemplary embodiment of the present application, if the number of the target event types is greater than 1, the generating unit 904 generates a buried point file according to the target event types, including:

and generating a buried point file according to the target attribute name set.

In an exemplary embodiment of the present application, the applet updating unit 905 updates the applet according to the buried point file, including:

a parameter receiving unit (not shown) configured to receive parameters returned by all functions in the updated applet when the updated applet is executed after the applet is updated by the applet updating unit 905 according to the buried point file; wherein the function comprises an event handling function;

and a buried point unit (not shown) for intercepting the parameter and executing the buried point operation when the parameter matches any target attribute name in the buried point file.

a matching unit (not shown) for determining a specific attribute value corresponding to the parameter before the embedded point unit intercepts the parameter and executes the embedded point operation; matching a specific attribute name corresponding to the specific attribute value in the mapping relation; and if the matching is successful, judging that the parameters are matched with any target attribute name in the embedded point file.

It should be noted that although in the above detailed description several modules or units of the device for action execution are mentioned, such a division is not mandatory. Indeed, the features and functionality of two or more modules or units described above may be embodied in one module or unit, according to embodiments of the application. Conversely, the features and functions of one module or unit described above may be further divided into embodiments by a plurality of modules or units.

For details that are not disclosed in the embodiments of the apparatus of the present application, please refer to the above-mentioned embodiments of the method for embedding a point to be monitored for an event of the present application.

As another aspect, the present application also provides a computer-readable medium, which may be contained in the electronic device described in the above embodiments; or may exist separately without being assembled into the electronic device. The computer readable medium carries one or more programs which, when executed by an electronic device, cause the electronic device to implement the method described in the above embodiments.

It should be noted that the computer readable medium shown in the present application may be a computer readable signal medium or a computer readable storage medium or any combination of the two. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples of the computer readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the present application, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In this application, however, a computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wire, fiber optic cable, RF, etc., or any suitable combination of the foregoing.

The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present application. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams or flowchart illustration, and combinations of blocks in the block diagrams or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

The units described in the embodiments of the present application may be implemented by software or hardware, and the described units may also be disposed in a processor. Wherein the names of the elements do not in some way constitute a limitation on the elements themselves.

Other embodiments of the present application will be apparent to those skilled in the art from consideration of the specification and practice of the invention disclosed herein. This application is intended to cover any variations, uses, or adaptations of the invention following, in general, the principles of the application and including such departures from the present disclosure as come within known or customary practice within the art to which the invention pertains. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the application being indicated by the following claims.

It will be understood that the present application is not limited to the precise arrangements described above and shown in the drawings and that various modifications and changes may be made without departing from the scope thereof. The scope of the application is limited only by the appended claims.

Claims

1. A method for embedding points for an event to be monitored is characterized by comprising the following steps:

acquiring a plurality of types of project files for constituting the applet;

extracting a target file corresponding to a specific type from the plurality of types of project files; wherein the plurality of types includes the particular type;

determining a target event type meeting a preset condition from a plurality of event types included in the target file; wherein the target event type corresponds to at least one event to be monitored;

and generating a buried point file according to the type of the target event, and updating the applet according to the buried point file so as to realize monitoring of the event to be monitored when the event to be monitored is triggered.

2. The method of claim 1, wherein obtaining a plurality of types of project files for composing an applet comprises:

copying multiple types of project files corresponding to the small programs in a development directory;

and pasting the copied multiple types of project files to a target directory to achieve the acquisition of the multiple types of project files.

3. The method of claim 1, wherein extracting target files corresponding to a specific type from the plurality of types of project files comprises:

and extracting target files corresponding to the at least one specific type from the plurality of types of project files.

4. The method of claim 1, wherein the plurality of types of project files correspond to different file formats, the file formats including at least one of a wxml format, a js format, and a json format.

5. The method according to claim 1, wherein determining a target event type satisfying a preset condition from a plurality of event types included in the target file comprises:

determining type information defined by the preset condition;

and determining the target event type from a plurality of event types included in the target file according to the type information.

6. The method according to claim 5, wherein the plurality of event types are represented by attribute names, the event processing functions corresponding to the plurality of event types are represented by attribute values, and the attribute names and the attribute values are associated by a mapping relationship.

7. The method of claim 6, wherein determining the target event type from a plurality of event types included in the target file according to the type information comprises:

and determining a target attribute name for representing the target event type from the target file according to the type information.

8. The method of claim 7, wherein if the number of the target event types is greater than 1, generating a buried point file according to the target event types comprises:

collecting the target attribute names of the target event types to obtain a target attribute name set;

and generating a buried point file according to the target attribute name set.

9. The method of claim 1, wherein updating the applet based on the buried point file comprises:

adding the buried point file in a plurality of types of project files for constituting the applet to realize the update for the applet.

10. The method of claim 6, wherein after updating the applet from the buried point file, the method further comprises:

when the updated applet is executed, receiving parameters returned by all functions in the updated applet; wherein the function comprises the event handling function;

and if the parameter is matched with any target attribute name in the embedded point file, intercepting the parameter and executing embedded point operation.

11. The method of claim 10, wherein prior to intercepting the parameter and performing a fixed point operation, the method further comprises:

determining a specific attribute value corresponding to the parameter;

matching a specific attribute name corresponding to the specific attribute value in the mapping relation;

and if the matching is successful, judging that the parameters are matched with any target attribute name in the buried point file.

12. The method of claim 11, wherein intercepting the parameter and performing a fixed point operation comprises:

intercepting the parameters through an interception function and executing a point burying operation;

13. A fixed point device for an event to be monitored, comprising:

a file extracting unit for extracting a target file corresponding to a specific type from the plurality of types of project files; wherein the plurality of types includes the particular type;

an event type determining unit, configured to determine a target event type that satisfies a preset condition from among multiple event types included in the target file; wherein the target event type corresponds to at least one event to be monitored;

the buried point file generating unit is used for generating a buried point file according to the target event type;

and the applet updating unit is used for updating the applet according to the buried point file so as to monitor the event to be monitored when the event to be monitored is triggered.

14. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the method of any one of claims 1-12.

15. An electronic device, comprising:

a processor; and

a memory for storing executable instructions of the processor;

wherein the processor is configured to perform the method of any of claims 1-12 via execution of the executable instructions.