WO2020252724A1

WO2020252724A1 - Log processing method and device, and computer-readable storage medium

Info

Publication number: WO2020252724A1
Application number: PCT/CN2019/091998
Authority: WO
Inventors: 廖凯; 邱桂添
Original assignee: 深圳市大疆创新科技有限公司
Priority date: 2019-06-20
Filing date: 2019-06-20
Publication date: 2020-12-24
Also published as: CN111699479A

Abstract

Provided in the embodiments of the present invention are a log processing method and device, and a computer-readable storage medium. The method comprises: a client sending a registration request to a server by means of a preset calling interface; the server receiving the registration request sent by the client; the server applying for a shared memory for the client according to the registration request; after the shared memory is applied for successfully, the server sending registration success information to the client; when receiving the registration success information fed back by the server, the client writing log information of the client into the shared memory; and the server acquiring the log information from the shared memory, and storing the log information to a preset storage path. Since the server can apply for, according to at least one thread of at least one client, the shared memory for the client corresponding to the thread, the log processing method can be applied to a high concurrency scenario, and then can effectively manage logs of a plurality of processes.

Description

Log processing method, equipment and computer readable storage medium

Technical field

The embodiments of the present invention relate to the field of communications, and in particular to a log processing method, device and computer-readable storage medium.

Background technique

Network equipment, systems and service programs, etc., will generate log logs during operation, and each log records the description of related operations such as date, time, user, and action. In practical applications, large software projects often generate a large number of logs. Because of the large number of logs, how to quickly communicate and store logs has become an urgent problem to be solved.

In the prior art, the storage of logs is generally implemented through a Syslog log system. Specifically, the Syslog log system supports local and remote log storage services by providing calling interfaces, configuration files, and daemon processes. The remote log storage service can obtain logs by monitoring fixed ports.

However, when the above method is used for log storage, two sockets are required to realize two-way data interaction, which is not suitable for high-concurrency scenarios, and the logs of multiple processes cannot be managed separately.

Summary of the invention

The embodiments of the present invention provide a log processing method, device, and computer-readable storage medium to solve the technical problem that the existing log processing method is not suitable for high-concurrency scenarios and cannot manage logs of multiple processes.

The first aspect of the embodiments of the present invention is to provide a log processing method, including:

The client sends a registration request to the server through the preset calling interface;

The server receives the registration request sent by the client;

The server applies for shared memory for the client according to the registration request;

After the shared memory application is successful, the server sends registration success information to the client;

When the client receives the registration success information fed back by the server, writes the log information of the client into the shared memory;

The server obtains the log information from the shared memory and stores it in a preset storage path.

The second aspect of the embodiments of the present invention is to provide a log processing method applied to a client, and the method includes:

Send a registration request to the server through the preset calling interface

When the registration success information fed back by the server is received, the log information of the client is written into the shared memory of the client and the server.

The third aspect of the embodiments of the present invention is to provide a log processing method applied to the server, and the method includes:

Receive the registration request sent by the client;

Apply for shared memory for the client according to the registration request;

After the shared memory application is successful, send registration success information to the client;

Obtain the log information of the client from the shared memory of the client and the server, and store it in a preset storage path.

The fourth aspect of the embodiments of the present invention is to provide a log processing system, including

One or more processors;

One or more memories;

The memory is used to store program codes;

The processor is used to call the program code, and when the program code is executed, it is used to perform the following operations:

Send a registration request to the server through the call interface preset by the client;

Receiving the registration request sent by the client through the server;

Apply for shared memory for the client through the server according to the registration request;

After the shared memory application is successful, send registration success information to the client through the server;

When receiving the registration success information fed back by the server, write the log information of the client into the shared memory through the client;

The log information is obtained from the shared memory through the server and stored in a preset storage path.

The fifth aspect of the embodiments of the present invention is to provide a client terminal device, and the terminal device includes:

Memory and processor;

The memory is used to store program codes;

The processor calls the program code, and when the program code is executed, is used to perform the following operations:

Send a registration request to the server through the preset calling interface

When the registration success information fed back by the server is received, the log information is written into the shared memory of the client and the server.

A sixth aspect of the embodiments of the present invention is to provide a service terminal device, where the service terminal device includes: a memory and a processor;

The memory is used to store program codes;

Receive the registration request sent by the client;

Apply for shared memory for the client according to the registration request;

Obtain the log information of the client from the shared memory and store it in a preset storage path.

A seventh aspect of the embodiments of the present invention is to provide a computer-readable storage medium on which a computer program is stored, and the computer program is executed by a processor to implement the method described in the first aspect or the second aspect or the third aspect .

The log processing method, device, and computer-readable storage medium provided in this embodiment send a registration request to the server through a preset calling interface, so that the server applies for shared memory for the client according to the registration request, and applies for shared memory After success, the registration success information is fed back to the client, where the client and the server share the shared memory. After receiving the registration success information fed back by the server, the log information generated by the client is written into the shared memory so that the server can obtain the log information written by the client from the shared memory and store it in the preset In the storage path. Since the server can apply for shared memory according to at least one thread of at least one client, it can be applied to high-concurrency scenarios, and can effectively manage the logs of multiple processes.

Description of the drawings

In order to explain the technical solutions in the embodiments of the present invention more clearly, the following will briefly introduce the drawings used in the description of the embodiments. Obviously, the drawings in the following description are some embodiments of the present invention. For those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative labor.

FIG. 1 is a schematic flowchart of a log processing method provided by Embodiment 1 of the present invention;

2 is a schematic flowchart of a log processing method provided by Embodiment 2 of the present invention;

3 is a schematic flowchart of a log processing method provided by Embodiment 3 of the present invention;

4 is a schematic flowchart of a log processing method provided by Embodiment 4 of the present invention;

FIG. 5 is a schematic flowchart of a log processing method according to Embodiment 5 of the present invention;

6 is a schematic flowchart of a log processing method provided by Embodiment 6 of the present invention;

FIG. 7 is a schematic flowchart of a log processing method provided by Embodiment 7 of the present invention;

FIG. 8 is a schematic flowchart of a log processing method provided by Embodiment 8 of the present invention;

9 is a schematic flowchart of a log processing method provided by Embodiment 9 of the present invention;

FIG. 10 is a schematic structural diagram of a client terminal device according to Embodiment 10 of the present invention;

FIG. 11 is a schematic structural diagram of a service terminal device provided by Embodiment 11 of the present invention.

Detailed ways

The technical solutions in the embodiments of the present invention will be clearly described below in conjunction with the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative work shall fall within the protection scope of the present invention.

It should be noted that when a component is said to be "fixed to" another component, it can be directly on the other component or a central component may also exist. When a component is considered to be "connected" to another component, it can be directly connected to another component or there may be a centered component at the same time.

Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by those skilled in the technical field of the present invention. The terms used in the description of the present invention herein are only for the purpose of describing specific embodiments, and are not intended to limit the present invention. The term "and/or" as used herein includes any and all combinations of one or more of the related listed items.

Hereinafter, some embodiments of the present invention will be described in detail with reference to the accompanying drawings. In the case of no conflict, the following embodiments and features in the embodiments can be combined with each other.

In order to solve the technical problem that the existing log processing method is not suitable for high concurrency scenarios and cannot manage the logs of multiple processes, the present invention provides a log processing method, device, and computer-readable storage medium. The present invention provides The log processing method, device, and computer-readable storage medium can be applied to any log processing scenario.

FIG. 1 is a schematic flowchart of a log processing method provided in Embodiment 1 of the present invention. As shown in FIG. 1, the log processing method includes:

Step 101: The client sends a registration request to the server through a preset calling interface;

Step 102: The server receives the registration request sent by the client.

Step 103: The server applies for shared memory for the client according to the registration request;

Step 104: After the shared memory application is successful, the server sends registration success information to the client;

Step 105: When receiving the registration success information fed back by the server, the client writes the log information of the client into the shared memory;

Step 106: The server obtains the log information from the shared memory and stores it in a preset storage path.

The execution subject of this embodiment is a log processing system, where the log processing system includes a client and a server. In order to realize the storage of log information, the client can send a registration request to the server through a preset calling interface. Correspondingly, after receiving the registration request, the server can determine whether to apply for shared memory for the client according to the registration request. For example, if the server’s current storage space is insufficient and its processing capacity is weak, it is not necessary to apply for shared memory for the client according to the registration request; if the server’s current storage space is large and its processing capacity is strong, it can be The registration request applies for shared memory for the client. The client and the server share the shared memory. Specifically, the client can write the generated log information into the shared memory, and the server can take out the log information from the shared memory. Further, after the server determines that it can apply for shared memory for the client according to the registration request, it can feed back registration success information to the client, so that the client can understand the status of the current registration request in time. When the client receives the registration success message sent by the server, it can write the log information that needs to be stored into the shared memory. Wherein, the registration success information may include the storage address of the shared memory, and the registration success information may be sent by the server to the client through a preset or newly added calling interface. Therefore, the server can obtain the log information stored by the client from the shared memory and store it in a preset storage path.

Optionally, on the basis of any of the foregoing embodiments, the shared memory is a locked queue instance.

Further, on the basis of any of the foregoing embodiments, the registration request is sent by one of the threads of the client.

In this embodiment, the registration request may specifically be sent by one of the threads in the client. Since there are multiple threads in the client, each thread can send a registration request to the server. Accordingly, the server can apply for shared memory for the client where the thread is located according to the registration request sent by each thread. By separately applying for shared memory for multiple threads of the client, it is possible to realize log storage under high concurrency.

In the log processing method provided in this embodiment, the client sends a registration request to the server through a preset calling interface; the server receives the registration request sent by the client; the server applies for shared memory for the client according to the registration request; when the shared memory applies After success, the server sends the registration success information to the client; when the client receives the registration success information fed back by the server, it writes the log information of the client to the shared memory; the server obtains the log information from the shared memory and stores it To the preset storage path. Since the server can apply for shared memory for the client corresponding to the thread according to at least one thread of at least one client, it can be applied to high-concurrency scenarios, and can effectively manage the logs of multiple processes.

Further, on the basis of any of the foregoing embodiments, the shared memory is a lock-free queue instance.

In this embodiment, the shared memory may specifically be a lock-free queue instance. The lock-free queue instance may be a lock-free queue instance implemented by a compare and replace (Compare and Set, CAS for short) mechanism, or any other one may be used. An example of a lock-free queue implemented by this mechanism is not limited in the present invention. Using a lock-free queue instance can save lock overhead on the basis of improving log processing efficiency.

The log processing method provided in this embodiment uses a lock-free queue instance as a shared memory, thereby improving the log processing effect, and further enabling log processing in a multi-process high-concurrency scenario.

Further, on the basis of any of the foregoing embodiments, the writing the log information of the client into the shared memory includes:

The log of each thread in the client is written into the shared memory according to a predetermined thread storage sequence.

In this embodiment, in order to improve the efficiency of log processing, a thread storage order can be preset. The thread storage order can be determined by one or more of the priority, urgency, data size, and sending time of each thread. In addition, the user can also make real-time adjustments according to current needs, and the present invention is not limited here. After receiving multiple registration requests sent by multiple threads in the client at the same time and applying for shared memory, the log information written by each thread can be written into the shared memory according to the above-mentioned thread storage order.

The log processing method provided in this embodiment can effectively improve the efficiency of log processing by writing the log of each thread in the client into the shared memory in a predetermined thread storage sequence.

Store log information with a priority higher than the preset first printing level in the shared memory.

In this embodiment, since the number of log information written by the client is large, different log information has different priorities. Therefore, in order to optimize the quality of log information and reduce storage space, after receiving the written log information, the priority of the log information can be determined first, and the log information with a priority higher than the preset first printing level can be written into the log information. In the shared memory, the first printing level may be set by the user according to actual needs, or may be a printing level preset by the system, which is not limited in the present invention.

Specifically, on the basis of any of the foregoing embodiments, the printing level of the log information includes OFF level, FATAL level, ERROR level, WARN level, INFO level, DEBUG level, and TRACE level in descending order of priority. And ALL level.

In the log processing method provided in this embodiment, log information with a priority higher than the preset first print level is stored in the shared memory, so that the quality of log information can be optimized and the storage space can be reduced. Log processing efficiency.

Further, on the basis of any of the foregoing embodiments, the writing the log information of the client to the shared memory includes:

The client writes the log information of the client into the shared memory in an asynchronous storage manner.

In this embodiment, since the existing log processing method generally waits for the server to feedback that the log information is stored successfully after the client writes the log information on the server, and performs subsequent log write operations, it is often more Time-consuming, resulting in low log processing efficiency. In order to improve the efficiency of log processing, the log information of the client can be written to the shared memory in the manner of asynchronous storage. Specifically, after the client writes the log information in the shared memory, the subsequent log writing operation can be performed without waiting for the storage success information fed back by the server.

The log processing method provided in this embodiment can effectively increase the log writing speed by writing the log information of the client into the shared memory in an asynchronous storage manner, thereby improving log processing efficiency. In addition, different from the Zlog log storage technical solution in the prior art, the storage of log information through asynchronous storage can effectively solve the problem of IO stuck in the prior art using synchronous Zlog storage, which is suitable for real-time requirements. Higher system.

Further, on the basis of any of the foregoing embodiments, before sending a registration request to the server through the calling interface preset by the client, the method further includes:

The client generates the registration request according to a preset log writing configuration.

In this embodiment, before sending the registration request to the server, the log writing configuration may be determined first. The log writing configuration may specifically be input by the user according to current requirements, or may be a default writing configuration, which is not limited in the present invention. Generate a registration request according to the log writing configuration, and send the registration request to the server, so that the server can apply for shared memory for the client according to the log writing configuration. The log writing configuration includes at least one of memory size to be occupied, storage mode, storage location, storage subfolder division, and storage subfolder size. Optionally, different priorities can correspond to different log writing configurations. For example, the log writing configuration with a lower priority can only include the memory size to be occupied, while the log writing of the client with a higher priority The configuration can also include other personalized demand parameters.

The log processing method provided in this embodiment generates the registration request according to a preset log writing configuration, so that on the basis of improving the log processing efficiency, the client's personalized requirements in the log writing process can be met.

Figure 2 is a schematic flow chart of the log processing method provided by the second embodiment of the present invention. On the basis of any of the above embodiments, as shown in Figure 2, when the registration success information fed back by the server is received, the After the log information of the client is written into the shared memory, it further includes:

Step 201: The client obtains the number of connections of the shared memory;

Step 202: The client determines whether the server is disconnected from the shared memory according to the number of connections.

In this embodiment, in order to achieve successful writing and storage of log information, the client and the server need to be connected to the shared memory at the same time. Therefore, in order to ensure that the server is not dropped during log processing, the number of shared memory connections can be obtained. It should be noted that when no server is disconnected, the total number of shared memory connections is the total number of servers and clients currently connected to the shared memory. Therefore, the current status of the server can be determined according to the number of connections. After determining the number of connections, you can determine whether the server is disconnected from the shared memory according to the number of connections.

In the log processing method provided in this embodiment, by acquiring the number of connections of the shared memory, it is determined whether the server is disconnected from the shared memory according to the number of connections. Thereby, the effectiveness of log writing can be ensured, and the efficiency of log processing can be further improved.

Further, on the basis of any of the foregoing embodiments, the determining whether the server is disconnected from the shared memory according to the number of connections includes:

If the client remains connected to the shared memory, and the number of connections is less than the preset total number of connections, it is determined that the server is disconnected from the shared memory; wherein, the total number of connections is The number of connections to the shared memory in the normal log storage state;

If the client remains connected to the shared memory and the number of connections is not less than the preset total number of connections, it is determined that the server is not disconnected from the shared memory.

In this embodiment, if the client is currently connected to the shared memory and the number of connections is less than the preset total number of connections, it can be determined that the server is disconnected from the shared memory, where the total number of connections is in the normal log storage state. The number of shared memory connections. Conversely, if the client is currently connected to the shared memory and the number of connections is not less than the preset total number of connections, it can be determined that the server is not currently disconnected. Taking a practical application as an example, if there is currently a client and a server connected to the shared memory, then the number of shared memory connections is 2. If the client detects that the current number of connections in the shared memory is 2, it can be determined that the current server is running normally and not disconnected. Correspondingly, if the client detects that the current number of connections in the shared memory is 1, it can be determined that the server has dropped In order to ensure the normal processing of log information, the server needs to be reminded.

The log processing method provided in this embodiment determines that the server is disconnected from the shared memory if the client remains connected to the shared memory and the number of connections is less than the preset total number of connections Connection; the total number of connections is the number of connections to the shared memory in the normal log storage state, if the client is connected to the shared memory, and the number of connections is not less than the preset total number of connections, it is determined The server is not disconnected from the shared memory. Thereby, the effectiveness of log writing can be ensured, and the efficiency of log processing can be further improved.

FIG. 3 is a schematic flowchart of a log processing method provided in Embodiment 3 of the present invention. Based on any of the above embodiments, as shown in FIG. 3, the method further includes:

Step 301: When it is determined that the server is disconnected, send a reconnection request to the server according to a preset frequency;

Step 302: When the server receives the reconnection request sent by the client, the server reconnects to the shared memory according to the reconnection request.

In this embodiment, if it is detected by the number of connections that the server is currently disconnected from the shared memory, it means that the server cannot obtain log information from the shared memory and store it in time, resulting in low log processing efficiency and causing the client to The shared memory is occupied for too long. Therefore, when it is determined that the server is disconnected, a reconnection request can be sent to the server at a preset frequency, so that the server can re-establish a communication connection with the shared memory according to the reconnection request. The preset frequency can be a preset frequency, or it can be set according to actual needs. For example, if the client has a higher priority, it can send a reconnection request at a higher frequency; if the client The occupied shared memory is relatively large, and the reconnection request can also be sent at a higher frequency, which is not limited in the present invention.

In the log processing method provided in this embodiment, by sending a reconnection request to the server at a preset frequency when it is determined that the server is disconnected, the server can connect to the shared memory according to the reconnection request , Which can ensure the effectiveness of log writing, and further improve the efficiency of log processing.

Further, on the basis of any of the above embodiments, the registration success information includes the identification code allocated by the server to the client; the reconnection request includes the identification code; The reconnection request to reconnect with the shared memory includes:

The server connects to the shared memory according to the identification code in the reconnection request.

In this embodiment, after successfully applying for shared memory, the server can send a registration success message to the client, where the registration success message includes the identification code assigned by the server to the client. After the client detects that the server is disconnected from the shared memory, it can send a reconnection request including the identification code to the server. Therefore, the server can reconnect to the shared memory according to the identification code.

In the log processing method provided in this embodiment, the identification code in the received registration success message is placed in the reconnection request and sent to the server, so that the server can reconnect to the shared memory according to the identification code, and then be able to On the basis of ensuring the validity of log writing, the efficiency of log processing is further improved.

Further, on the basis of any of the foregoing embodiments, the server obtains the log information from the shared memory and stores it in a preset storage path, including:

The server obtains log information with a priority higher than a preset second printing level from the shared memory, and stores it in a preset storage path.

In this embodiment, since the number of log information written by the client is large, different log information has different priorities. Therefore, in order to optimize the quality of log information and reduce storage space, when the server obtains the log information from the shared memory, it first needs to determine the priority of the log information and set the priority higher than the preset second printing level of the log information , Save to the preset storage path. Wherein, the second printing level can be set by the user according to actual needs, or can be a printing level preset by the system, which is not limited in the present invention.

The log processing method provided in this embodiment obtains log information with a priority higher than the preset second printing level from the shared memory and stores it in a preset storage path, thereby optimizing the quality of log information and reducing Improve log processing efficiency based on small storage space.

The server obtains the log information from the shared memory in a single-threaded manner and stores it in a preset storage path.

In this embodiment, in order to improve log processing efficiency, after the client writes the log information into the shared memory, the server can obtain the log information from the shared memory in a single process and store it in a preset storage path.

The log processing method provided in this embodiment can effectively increase the log writing speed by acquiring the log information from the shared memory in a single-threaded manner and storing it in a preset storage path, thereby improving log processing. effectiveness.

Further, on the basis of any of the foregoing embodiments, the registration request includes the amount of memory to be occupied, and the application for shared memory for the client according to the registration request includes:

Determine the current remaining amount of memory on the server;

The server applies for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied.

In this embodiment, the registration request may include the amount of memory to be occupied. Specifically, when the client sends a registration request to the server, it can determine the amount of memory to be occupied, and generate a registration request according to the amount of memory to be occupied. After receiving the registration request, the server can first determine the current remaining amount of memory, and apply for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied.

Specifically, on the basis of any of the foregoing embodiments, the applying for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied includes:

If the amount of memory to be occupied is less than the remaining amount of memory, apply for a shared memory corresponding to the amount of memory to be occupied for the client;

If the amount of memory to be occupied is not less than the remaining amount of memory, refuse to apply for shared memory for the client.

In this embodiment, if it is detected that the amount of memory to be occupied is less than the remaining amount of memory, the client can apply for shared memory corresponding to the amount of memory to be occupied; otherwise, if the amount of memory to be occupied is not less than the remaining amount of memory, it means The current remaining memory of the server is insufficient to apply for shared memory for the client. At this time, it can refuse to apply for shared memory for the client.

The log processing method provided in this embodiment determines the current remaining amount of memory on the server, and applies for shared memory for the client based on the remaining amount of memory and the amount of memory to be occupied, so that it can quickly apply for the client Shared memory improves log processing efficiency.

Further, on the basis of any of the foregoing embodiments, the registration request further includes the process identifier of the client;

Correspondingly, the applying for shared memory for the client according to the registration request includes:

Determine whether the process identifier is included in the preset process blacklist;

If it does not exist, apply for shared memory for the client;

If it exists, refuse to apply for shared memory for the client.

In this embodiment, the registration request also includes the process identification. For example, in actual applications, some clients may have maliciously written to logs. Therefore, the server can generate a blacklist based on historical experience. The blacklist Include the process ID. Therefore, after the server receives the registration request that includes the process ID, it can detect whether the process ID is included in the blacklist. If so, it can refuse to apply for shared memory for the client. Otherwise, it can be the client according to the registration request. Apply for shared memory. Optionally, the log information generated by some clients may be more important or some clients have higher priority. Therefore, the server may also generate a whitelist based on historical experience, where the whitelist includes the process identifier. Therefore, after the server receives the registration request including the process ID, it can detect whether the process ID is included in the whitelist. If so, it can provide the client corresponding to the process ID with larger shared memory, or can provide the process Identifies the corresponding client to store log information with lower priority.

As an implementable way, different clients have different priorities, and the server can provide different services to the clients according to different priorities. Therefore, after receiving the registration request including the process identifier, the server can first determine the priority corresponding to the process identifier, and provide the client with a service corresponding to the priority according to the priority.

The log processing method provided in this embodiment judges whether the process identifier is included in the preset process blacklist, if it does not exist, apply for shared memory for the process, and if it exists, refuse to apply for shared memory for the process , So that the server can selectively apply for shared memory for the client, and then can ensure the security of the server on the basis of ensuring the efficiency of log processing.

Further, on the basis of any of the foregoing embodiments, the registration request is generated according to a preset log writing configuration;

The applying for shared memory for the client according to the registration request includes:

The server applies for shared memory for the client according to the log writing configuration.

In this embodiment, before sending a registration request to the server, the client may first determine the log writing configuration, and generate a registration request according to the log writing configuration. The log writing configuration may specifically be input by the user according to current requirements, or may be a default writing configuration, which is not limited in the present invention. The server can apply for shared memory for the client according to the log writing configuration. The log writing configuration includes at least one of memory size to be occupied, storage mode, storage location, storage subfolder division, and storage subfolder size. The stored subfolders are used to divide the stored subfolders according to different functions of threads, and the stored subfolders can also be divided according to different types of logs. Optionally, different priorities can correspond to different log writing configurations. For example, the log writing configuration with a lower priority can only include the memory size to be occupied, while the log writing of the client with a higher priority The configuration can also include other personalized demand parameters.

According to the log processing method provided in this embodiment, by applying for shared memory for the client according to the log writing configuration, it is possible to improve the log processing efficiency and meet the client's personalized needs in the log writing process. .

Further, on the basis of any of the foregoing embodiments, after the application for shared memory for the client according to the registration request, the method further includes:

The server performs an initialization operation on the shared memory to obtain a lock-free queue instance.

In this embodiment, after the server applies for shared memory for the client according to the registration request, the shared memory may be initialized to obtain a lock-free queue instance. The lock-free queue instance can be a lock-free queue instance implemented by a Compare and Replace (Compare and Set, CAS for short) mechanism, or a lock-free queue instance implemented by any other mechanism, and the present invention is not limited here. . Using a lock-free queue instance can save lock overhead on the basis of improving log processing efficiency.

The log processing method provided in this embodiment obtains a lock-free queue instance by initializing the shared memory, thereby improving the log processing effect, and further enabling log processing in a multi-process high concurrency scenario.

Optionally, on the basis of any of the foregoing embodiments, after applying for shared memory for the client according to the registration request, the method further includes:

Perform an initialization operation on the shared memory to obtain a locked queue instance.

Further, on the basis of any of the foregoing embodiments, after the server sends registration success information to the client, the method further includes:

The server monitors the log writing status in the shared memory, and manages the client according to the monitoring result.

In this embodiment, the client can write log information in the shared memory after receiving the registration success information. In order to further improve the log processing efficiency, the server can monitor the log writing status in the shared memory, and control the client according to the monitoring results. For example, you can determine whether the client is a malicious client based on the log writing status, and whether the client is currently malfunctioning.

The log processing method provided in this embodiment monitors the log writing status in the shared memory, and manages and controls the client according to the monitoring result, so that the log processing efficiency can be improved on the basis of improving the log processing efficiency. Effective management and control.

Further, on the basis of any of the above embodiments, the server monitors the log writing status in the shared memory, and manages the client according to the monitoring result, including:

The server determines whether the speed at which the client writes the log exceeds a preset speed threshold;

If yes, it is determined that the client is faulty.

In this embodiment, the current speed at which the client writes the log can be determined, and the status of the client can be determined according to the speed. Specifically, if it is detected that the speed at which the client writes the log exceeds a preset speed threshold, it can be determined that the client is currently malfunctioning, anyway, it means that the current client is operating normally.

Optionally, on the basis of any of the foregoing embodiments, the monitoring of the log writing status in the shared memory and the management and control of the client according to the monitoring result includes:

Judging whether the number of logs written by the client exceeds a preset number threshold;

If yes, it is determined that the client is faulty.

In this embodiment, the number of logs currently written by the client can be determined, and the status of the client can be determined according to the number. Specifically, if it is detected that the number of logs written by the client exceeds a preset number threshold, it can be determined that the client is currently malfunctioning, otherwise, it means that the current client is operating normally.

It should be noted that the above two embodiments can be implemented separately or in combination. When it is implemented in combination, it can be determined whether the number of logs currently written by the client exceeds the preset number threshold and whether the speed of the client currently writing logs exceeds the preset speed according to the number and speed of logs currently written by the client The threshold, if yes, it is determined that the client is currently malfunctioning, anyway, it means that the current client is operating normally.

The log processing method provided in this embodiment determines whether the client is currently malfunctioning by determining whether the number and/or speed of logs currently written by the client exceed the preset number and/or speed threshold, which can effectively achieve the End monitoring.

Further, on the basis of any of the foregoing embodiments, after determining that the client is faulty, the method further includes:

Determining, by the server, the authority information corresponding to the client according to the process identifier of the client;

The server manages and controls the log information written by the client according to the authority information.

In this embodiment, after determining that the client is faulty, the permission information corresponding to the client can be determined according to the process identifier of the client, and the log information written by the client can be controlled according to the permission information. Take a practical application as an example, if the priority of the client currently writing logs is higher, when it is detected that the number and/or speed of the client currently writing logs exceeds the preset number and/or speed threshold, the All log information is stored; accordingly, if the priority of the client currently writing to the log is lower, when it is detected that the number and/or speed of the current written log of the client exceeds the preset number and/or speed threshold, Part of the log information written by the client can be stored, or the client can be refused to continue to provide shared memory.

In the log processing method provided in this embodiment, the authority information corresponding to the client is determined according to the process identifier, and the log information written by the client is controlled according to the authority information, so as to be effective for the client. Control.

Further, on the basis of any of the foregoing embodiments, the method includes:

The server obtains the log information from the shared memory, and publishes the log information.

In this embodiment, the client writes the log information into the shared memory, and the server can obtain the log information from the shared memory and perform publishing processing.

FIG. 4 is a schematic flow chart of a log processing method provided by Embodiment 4 of the present invention, which is applied to a client terminal. As shown in FIG. 4, the method includes:

Step 401: Send a registration request to the server through a preset calling interface.

The execution subject of this embodiment is a client, where the client may be an application, a process, or a terminal device. In order to realize the storage of log information, the client can send a registration request to the server through a preset calling interface. Correspondingly, after receiving the registration request, the server can determine whether to apply for shared memory for the client according to the registration request. For example, if the server’s current storage space is insufficient and its processing capacity is weak, it is not necessary to apply for shared memory for the client according to the registration request; if the server’s current storage space is large and its processing capacity is strong, it can be The registration request applies for shared memory for the client. The client and the server share the shared memory. Specifically, the client can write the generated log information into the shared memory, and the server can take out the log information from the shared memory. Further, after the server determines that it can apply for shared memory for the client according to the registration request, it can feed back registration success information to the client, so that the client can understand the status of the current registration request in time.

Step 402: When the registration success information fed back by the server is received, the log information of the client is written into the shared memory.

In this embodiment, when the client receives the registration success information sent by the server, it can write the log information that needs to be stored into the shared memory. Wherein, the registration success information may include the storage address of the shared memory, and the registration success information may be sent by the server to the client through a preset or newly added calling interface. Therefore, the server can obtain the log information stored by the client from the shared memory and store it in a preset storage path.

The log processing method provided in this embodiment sends a registration request to the server through a preset calling interface, so that the server applies for shared memory for the client according to the registration request, and reports the successful registration to the client after the shared memory application is successful Information, where the client and server share the shared memory. After receiving the registration success information fed back by the server, the log information generated by the client is written into the shared memory so that the server can obtain the log information written by the client from the shared memory and store it in the preset In the storage path. Since the server can apply for shared memory according to at least one thread of at least one client, it can be applied to high-concurrency scenarios, and can effectively manage the logs of multiple processes.

The log information of the client is written into the shared memory in an asynchronous storage manner.

Further, on the basis of any of the foregoing embodiments, the registration information also includes the process identifier of the process that sent the registration request, so that the server can determine whether to provide the process for the process according to the process identifier. Memory information.

In this embodiment, the registration information also includes the process identifier of the process that sent the registration request. Taking a practical application as an example, some clients may have malicious write operations to logs. Therefore, the server can generate a blacklist based on historical experience, where the blacklist includes the process identifier. Therefore, after the server receives the registration request that includes the process ID, it can detect whether the process ID is included in the blacklist. If so, it can refuse to apply for shared memory for the client. Otherwise, it can be the client according to the registration request. Apply for shared memory. Optionally, the log information generated by some clients may be more important or some clients have a higher priority. Therefore, the server may also generate a whitelist based on historical experience, where the whitelist includes the process identifier. Therefore, after the server receives the registration request including the process ID, it can detect whether the process ID is included in the whitelist. If so, it can provide the client corresponding to the process ID with larger shared memory, or can provide the process Identifies the corresponding client to store log information with lower priority.

In the log processing method provided in this embodiment, the registration information also includes the process identification of the process that sent the registration request, so that the server can selectively apply for shared memory for the client, thereby ensuring log processing efficiency. , To ensure the security of the server.

The registration request is generated according to the preset log writing configuration.

FIG. 5 is a schematic flowchart of a log processing method provided by Embodiment 5 of the present invention. On the basis of any of the above embodiments, as shown in FIG. 5, when the registration success information fed back by the server is received, the After the log information of the client is written into the shared memory, it further includes:

Step 501: Obtain the number of connections of the shared memory.

Step 502: Determine whether the server is disconnected from the shared memory according to the number of connections.

If the client remains connected to the shared memory, and the number of connections is less than the preset total number of connections, it is determined that the server is disconnected from the shared memory; the total number of connections is a normal log The number of connections of the shared memory in the storage state;

Further, on the basis of any of the foregoing embodiments, the method further includes:

When it is determined that the server is disconnected, a reconnection request is sent to the server at a preset frequency.

In the log processing method provided in this embodiment, when it is determined that the server is disconnected, a reconnection request is sent to the server at a preset frequency, so that the server can connect according to the reconnection request. The shared memory can ensure the effectiveness of log writing, and further improve the efficiency of log processing.

Further, on the basis of any of the foregoing embodiments, the registration success information includes an identification code allocated by the server to the client; the reconnection request includes the identification code; the identification code is used Therefore, the server can connect to the shared memory according to the identification code in the reconnection request.

In this embodiment, after successfully applying for shared memory, the server may send registration success information to the client, where the registration success information includes the identification code assigned by the server to the client. After the client detects that the server is disconnected from the shared memory, it can send a reconnection request including the identification code to the server. Therefore, the server can reconnect to the shared memory according to the identification code.

In the log processing method provided in this embodiment, the identification code in the received registration success message is placed in the reconnection request and sent to the server, so that the server can reconnect to the shared memory according to the identification code, thereby enabling On the basis of ensuring the validity of log writing, the efficiency of log processing is further improved.

FIG. 6 is a schematic flowchart of a log processing method provided by Embodiment 6 of the present invention, which is applied to the server side. As shown in FIG. 6, the method includes:

Step 601: Receive a registration request sent by the client.

Step 602: Apply for shared memory for the client according to the registration request;

Step 603: After the shared memory application is successful, send registration success information to the client;

Step 604: Obtain the log information from the shared memory and store it in a preset storage path.

The execution body of this embodiment is the server, where the server can be an application, a process, or a terminal device. In order to store log information, the client can use a preset calling interface to The server sends a registration request. Correspondingly, the server can receive the registration request sent by the client, and apply for shared memory for the client according to the registration request. For example, if the server’s current storage space is insufficient and its processing capacity is weak, it is not necessary to apply for shared memory for the client according to the registration request; if the server’s current storage space is large and its processing capacity is strong, it can be The registration request applies for shared memory for the client. After successfully applying for shared memory for the client, the registration success message can be sent to the client. When receiving the registration success information sent by the server, the client can write log information that needs to be stored into the shared memory, where the registration success information can include the storage address of the shared memory. Since the client and the server are connected to the shared memory at the same time, after the client writes the log information in the shared memory, the server can obtain the log information from the shared memory and store it in a preset storage path.

Further, the registration request is sent by one of the threads of the client.

In this embodiment, the registration request may specifically be sent by one of the threads in the client. Since there are multiple threads in the client, each thread can send a registration request to the server. Accordingly, the server can apply for shared memory for the client corresponding to the thread according to the registration request sent by each thread. By separately applying for shared memory for multiple threads of the client, it is possible to realize log storage under high concurrency.

Further, when the client finishes writing all the log information, the client disconnects from the shared memory, and the server can reclaim the shared memory currently used by the client so that no other clients can apply for it later.

The log processing method provided in this embodiment receives a registration request sent by a client, applies for shared memory for the client according to the registration request, and sends a registration success message to the client after the shared memory application is successful , So that the client writes log information in the shared memory according to the registration success information, acquires the log information from the shared memory, and stores it in a preset storage path. Since the server can apply for shared memory according to at least one thread of at least one client, the log information generated by all processes in the client can be stored in the shared memory, which can be applied to the high concurrency of multiple threads in an application. In turn, the logs of multiple processes can be effectively managed.

Further, on the basis of any of the foregoing embodiments, the acquiring the log information from the shared memory and storing it in a preset storage path includes:

Obtain log information with a priority higher than the preset second printing level from the shared memory, and store it in a preset storage path.

Further, on the basis of any of the foregoing embodiments, the server acquiring the log information from the shared memory and storing it in a preset storage path includes:

FIG. 7 is a schematic flow chart of a log processing method provided by Embodiment 7 of the present invention. Based on any of the foregoing embodiments, as shown in FIG. 7, the registration request includes the amount of memory to be occupied, and the The request to apply for shared memory for the client includes:

Step 701: Determine the current remaining amount of memory on the server;

Step 702: Apply for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied.

In this embodiment, if it is detected that the amount of memory to be occupied is less than the remaining amount of memory, the client can apply for shared memory corresponding to the amount of memory to be occupied; otherwise, if the amount of memory to be occupied is not less than the remaining amount of memory, the The current remaining memory of the server is insufficient to apply for shared memory for the client. At this time, it can refuse to apply for shared memory for the client.

FIG. 8 is a schematic flowchart of a log processing method provided by Embodiment 8 of the present invention. On the basis of any of the above embodiments, as shown in FIG. 8, the registration request also includes the process identifier; accordingly, the Applying for shared memory for the client according to the registration request includes:

Step 801: Determine whether the process identifier is included in the preset process blacklist;

Step 802: If it does not exist, apply for shared memory for the process;

Step 803: If it exists, refuse to apply for shared memory for the process.

Apply for shared memory for the client according to the log writing configuration.

In this embodiment, before sending a registration request to the server, the client may first determine the log writing configuration, and generate a registration request according to the log writing configuration. The log writing configuration may specifically be input by the user according to current requirements, or may be a default writing configuration, which is not limited in the present invention. The server can apply for shared memory for the client according to the log writing configuration. The log writing configuration includes at least one of memory size to be occupied, storage mode, storage location, storage subfolder division, and storage subfolder size. Among them, the stored subfolders are used to divide the stored subfolders according to different functions of threads, and the stored subfolders may also be divided according to different types of logs. Optionally, different priorities can correspond to different log writing configurations. For example, the log writing configuration with a lower priority can only include the memory size to be occupied, while the log writing of the client with a higher priority The configuration can also include other personalized demand parameters.

Perform an initialization operation on the shared memory to obtain a lock-free queue instance.

When receiving the reconnection request sent by the client, reconnect with the shared memory according to the reconnection request.

In this embodiment, in order to achieve successful writing and storage of log information, the client and the server need to be connected to the shared memory at the same time. Therefore, when the client detects that the server is disconnected from the shared memory, it can send a reconnection request to the server. Correspondingly, after receiving the reconnection request, the server can re-establish a communication connection with the shared memory according to the reconnection request.

In the log processing method provided in this embodiment, when a reconnection request sent by the client is received, it reconnects to the shared memory according to the reconnection request. Thereby, the effectiveness of log writing can be ensured, and the efficiency of log processing can be further improved.

Further, on the basis of any of the foregoing embodiments, the registration success information includes the identification code allocated by the server to the client; the reconnection request includes the identification code; The reconnection request to reconnect with the shared memory includes:

Connect to the shared memory according to the identification code in the reconnection request.

The log processing method provided in this embodiment connects to the shared memory according to the identification code in the reconnection request, so that the server can reconnect to the shared memory according to the identification code, and thus can ensure that the log is written On the basis of the effectiveness, the efficiency of log processing is further improved.

Further, on the basis of any of the foregoing embodiments, after the sending of registration success information to the client, the method further includes:

The log writing status in the shared memory is monitored, and the client is managed and controlled according to the monitoring result.

Further, on the basis of any of the foregoing embodiments, the monitoring of the log writing status in the shared memory and the management and control of the client according to the monitoring result includes:

Determining whether the speed at which the client writes the log exceeds a preset speed threshold;

If yes, it is determined that the client is faulty.

Fig. 9 is a schematic flowchart of a log processing method according to the ninth embodiment of the present invention. Based on any of the foregoing embodiments, as shown in Fig. 9, after determining that the client is faulty, the method further includes:

Step 901: Determine permission information corresponding to the client according to the process identifier.

Step 902: Manage and control the log information written by the client according to the authority information.

Further, on the basis of any of the foregoing embodiments, the method further includes: acquiring the log information from the shared memory, and performing publishing processing on the log information.

FIG. 10 is a schematic structural diagram of a client terminal device according to Embodiment 10 of the present invention. As shown in FIG. 10, the terminal device includes:

Memory 111 and processor 112;

The memory 111 is used to store program codes;

The processor 112 calls the program code, and when the program code is executed, is configured to perform the following operations:

Send a registration request to the server through the preset calling interface;

When the registration success information fed back by the server is received, the log information of the client is written into the shared memory.

Further, on the basis of any of the foregoing embodiments, the shared memory is an example of a locked queue.

Further, on the basis of any of the foregoing embodiments, when the processor writes the log information of the client into the shared memory, it is configured to:

Further, on the basis of any of the foregoing embodiments, the printing level of the log information includes OFF level, FATAL level, ERROR level, WARN level, INFO level, DEBUG level, and TRACE level in descending order of priority. And ALL level.

Further, on the basis of any of the foregoing embodiments, when the processor writes the log information of the client to the shared memory, it is configured to:

Further, on the basis of any of the foregoing embodiments, before sending a registration request to the server through the calling interface preset by the client, the processor is further configured to:

Further, on the basis of any of the foregoing embodiments, the log writing configuration includes at least one of the size of the memory to be occupied, the storage mode, the storage location, the division of storage subfolders, and the size of the storage subfolders.

Further, on the basis of any of the foregoing embodiments, after the processor writes the log information of the client into the shared memory when receiving the registration success information fed back by the server, it also uses in:

Acquiring the number of connections of the shared memory;

Determine whether the server is disconnected from the shared memory according to the number of connections.

Further, on the basis of any of the foregoing embodiments, when determining whether the server is disconnected from the shared memory according to the number of connections, the processor is configured to:

Further, on the basis of any of the foregoing embodiments, the processor is further configured to:

FIG. 11 is a schematic structural diagram of a service terminal device according to Embodiment 11 of the present invention. As shown in FIG. 11, the service terminal device includes: a memory 121 and a processor 122;

The memory 121 is used to store program codes;

The processor 122 calls the program code, and when the program code is executed, is used to perform the following operations:

Receive the registration request sent by the client;

Apply for shared memory for the client according to the registration request;

After the shared memory application is successful, the registration success information is sent to the client, so that the client writes log information in the shared memory according to the registration success information, and the registration success information includes all The shared memory;

The log information is obtained from the shared memory and stored in a preset storage path.

Further, on the basis of any of the foregoing embodiments, when the processor obtains the log information from the shared memory and stores it in a preset storage path, it is configured to:

Further, on the basis of any of the foregoing embodiments, when the server obtains the log information from the shared memory and stores it in a preset storage path, the processor is configured to:

Further, on the basis of any of the foregoing embodiments, the registration request includes the amount of memory to be occupied, and when applying for shared memory for the client according to the registration request, the processor is configured to:

Determine the current remaining amount of memory on the server;

Apply for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied.

Further, on the basis of any of the foregoing embodiments, when the processor applies for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied, the processor is configured to:

Further, on the basis of any of the foregoing embodiments, the registration request further includes the process identifier;

Correspondingly, when applying for shared memory for the client according to the registration request, the processor is configured to:

If it does not exist, apply for shared memory for the process;

If it exists, refuse to apply for shared memory for the process.

When applying for shared memory for the client according to the registration request, the processor is configured to:

Further, on the basis of any of the foregoing embodiments, after applying for shared memory for the client according to the registration request, the processor is further configured to:

Further, on the basis of any of the foregoing embodiments, an initialization operation is performed on the shared memory to obtain a locked queue instance.

Further, on the basis of any of the foregoing embodiments, the registration success information includes an identification code assigned by the server to the client; the reconnection request includes the identification code; the processor is When reconnecting to the shared memory according to the reconnection request, it is used to:

Further, on the basis of any of the foregoing embodiments, after sending the registration success information to the client, the processor is further configured to:

Further, on the basis of any one of the foregoing embodiments, the processor is configured to monitor the log writing status in the shared memory and to manage and control the client according to the monitoring result:

If yes, it is determined that the client is faulty.

Further, on the basis of any of the foregoing embodiments, when the processor monitors the log writing status in the shared memory, and controls the client according to the monitoring result, it is configured to:

If yes, it is determined that the client is faulty.

Further, on the basis of any of the foregoing embodiments, after determining that the client has a fault, the processor is further configured to:

Determining the authority information corresponding to the client according to the process identifier;

The log information written by the client is managed and controlled according to the authority information.

Further, on the basis of any of the foregoing embodiments, the processor is further configured to: obtain the log information from the shared memory, and perform publishing processing on the log information.

The present invention also provides a log processing system, which includes

One or more processors;

One or more memories;

The memory is used to store program codes;

The server receives the registration request sent by the client;

It should be noted that the above method can be completed by one processor or by multiple servers. When completed by a processor, the client program and the server program are both set in the same device. When completed by multiple servers, the client program corresponds to one processor for execution, and the server program corresponds to one processor for execution. The two can be set in the same device or in two independent devices. The present invention is There is no restriction.

Further, on the basis of any of the foregoing embodiments, the shared memory is a locked queue instance.

Further, on the basis of any of the foregoing embodiments, when the processor writes the log information of the client into the shared memory through the client, it is configured to:

The log of each thread in the client is written into the shared memory through the client according to a predetermined thread storage sequence.

The log information whose priority is higher than the preset first printing level is stored in the shared memory through the client.

The log information of the client is written into the shared memory through the client in an asynchronous storage manner.

The registration request is generated by the client according to a preset log writing configuration.

Further, on the basis of any of the foregoing embodiments, when the processor receives the registration success information fed back by the server, writes the log information of the client into the shared memory through the client After the middle, it is also used for:

Acquiring the number of connections of the shared memory through the client;

The client determines whether the server is disconnected from the shared memory according to the number of connections.

Further, on the basis of any of the foregoing embodiments, when the processor determines whether the server is disconnected from the shared memory according to the number of connections through the client, it is configured to:

If the client remains connected to the shared memory, and the number of connections is less than the preset total number of connections, the client determines that the server is disconnected from the shared memory; wherein, The total number of connections is the number of connections of the shared memory in the normal log storage state;

If the client maintains a connection with the shared memory, and the number of connections is not less than a preset total number of connections, it is determined by the client that the server is not disconnected from the shared memory.

When it is determined that the server is disconnected, sending a reconnection request to the server through the client according to a preset frequency;

When the server receives the reconnection request sent by the client, the server reconnects to the shared memory according to the reconnection request.

Further, on the basis of any of the foregoing embodiments, the registration success information includes the identification code allocated by the server to the client; the reconnection request includes the identification code; the processor is passing When the server reconnects to the shared memory according to the reconnection request, it is used to:

Connect to the shared memory through the server according to the identification code in the reconnection request.

Further, on the basis of any of the foregoing embodiments, when the processor obtains the log information from the shared memory through the server and stores it in a preset storage path, it is configured to:

Obtain log information with a priority higher than a preset second printing level from the shared memory through the server, and store it in a preset storage path.

The log information is obtained from the shared memory in a single-threaded manner through the server and stored in a preset storage path.

Further, on the basis of any of the foregoing embodiments, the registration request includes the amount of memory to be occupied, and the processor uses the server to apply for shared memory for the client according to the registration request. in:

Determine the current remaining amount of memory on the server;

Further, on the basis of any of the foregoing embodiments, when the processor applies for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied through the server, the processor is configured to:

Correspondingly, when applying for shared memory for the client through the server according to the registration request, the processor is configured to:

If it does not exist, apply for shared memory for the client;

If it exists, refuse to apply for shared memory for the client.

When the processor applies for shared memory for the client according to the registration request through the server, it is configured to:

Further, on the basis of any of the foregoing embodiments, after the processor receives the registration request sent by the client through the server, the processor further includes:

The server initializes the shared memory to obtain a locked queue instance.

Further, on the basis of any of the foregoing embodiments, after the processor sends registration success information to the client through the server, the processor further includes:

The log writing status in the shared memory is monitored by the server, and the client is managed and controlled according to the monitoring result.

Further, on the basis of any of the foregoing embodiments, the processor monitors the log writing status in the shared memory through the server, and controls the client according to the monitoring result. in:

If yes, it is determined that the client is faulty.

The server determines whether the number of logs written by the client exceeds a preset number threshold;

If yes, it is determined that the client is faulty.

Further, on the basis of any of the foregoing embodiments, the processor is configured to:

In addition, this embodiment also provides a computer-readable storage medium on which a computer program is stored, and the computer program is executed by a processor to implement the log processing method described in the foregoing embodiment.

In the several embodiments provided by the present invention, it should be understood that the disclosed device and method may be implemented in other ways. For example, the device embodiments described above are only illustrative. For example, the division of the units is only a logical function division, and there may be other divisions in actual implementation, for example, multiple units or components can be combined or It can be integrated into another system, or some features can be ignored or not implemented. In addition, the displayed or discussed mutual coupling or direct coupling or communication connection may be indirect coupling or communication connection through some interfaces, devices or units, and may be in electrical, mechanical or other forms.

The units described as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, they may be located in one place, or they may be distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the objectives of the solutions of the embodiments.

In addition, the functional units in the various embodiments of the present invention may be integrated into one processing unit, or each unit may exist alone physically, or two or more units may be integrated into one unit. The above-mentioned integrated unit may be implemented in the form of hardware, or may be implemented in the form of hardware plus software functional units.

The above-mentioned integrated unit implemented in the form of a software functional unit may be stored in a computer readable storage medium. The above-mentioned software functional unit is stored in a storage medium and includes several instructions to make a computer device (which may be a personal computer, a server, or a network device, etc.) or a processor execute the method described in the various embodiments of the present invention. Part of the steps. The aforementioned storage media include: U disk, mobile hard disk, read-only memory (Read-Only Memory, ROM), random access memory (Random Access Memory, RAM), magnetic disk or optical disk and other media that can store program code .

Those skilled in the art can clearly understand that, for the convenience and conciseness of the description, only the division of the above-mentioned functional modules is used as an example. In practical applications, the above-mentioned functions can be allocated by different functional modules as required, namely, the device The internal structure is divided into different functional modules to complete all or part of the functions described above. For the specific working process of the device described above, reference may be made to the corresponding process in the foregoing method embodiment, which is not repeated here.

Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, but not to limit it; although the present invention has been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand: It is still possible to modify the technical solutions described in the foregoing embodiments, or equivalently replace some or all of the technical features; these modifications or replacements do not make the essence of the corresponding technical solutions deviate from the technical solutions of the embodiments of the present invention range.

Claims

A log processing method, characterized by comprising:

The client sends a registration request to the server through the preset calling interface;

The server receives the registration request sent by the client;

The server applies for shared memory for the client according to the registration request;

After the shared memory application is successful, the server sends registration success information to the client;

When the client receives the registration success information fed back by the server, writes the log information of the client into the shared memory;

The server obtains the log information from the shared memory and stores it in a preset storage path.
The method according to claim 1, wherein the shared memory is a lock-free queue instance.
The method according to claim 1, wherein the shared memory is a locked queue instance.
The method according to claim 1, wherein the registration request is sent by one of the threads of the client.
The method according to claim 4, wherein the writing the log information of the client into the shared memory comprises:

The log of each thread in the client is written into the shared memory according to a predetermined thread storage sequence.
The method according to any one of claims 1-5, wherein the writing the log information of the client into the shared memory comprises:

Store log information with a priority higher than the preset first printing level in the shared memory.
The method according to any one of claims 1-5, wherein the printing level of the log information includes OFF level, FATAL level, ERROR level, WARN level, INFO level, DEBUG level, TRACE level and ALL level.
The method according to any one of claims 1-5, wherein the writing the log information of the client into the shared memory comprises:

The client writes the log information of the client into the shared memory in an asynchronous storage manner.
The method according to claim 1, wherein before the sending a registration request to the server through the calling interface preset by the client, the method further comprises:

The client generates the registration request according to a preset log writing configuration.
The method according to claim 9, wherein the log writing configuration includes at least one of a memory size to be occupied, a storage mode, a storage location, a storage subfolder division, and a storage subfolder size.
The method according to any one of claims 1-5 and 9-10, wherein when the registration success information fed back by the server is received, the log information of the client is written into the shared After in memory, it also includes:

Acquiring, by the client, the number of connections of the shared memory;

The client determines whether the server is disconnected from the shared memory according to the number of connections.
The method according to claim 11, wherein the determining whether the server is disconnected from the shared memory according to the number of connections comprises:

If the client remains connected to the shared memory, and the number of connections is less than the preset total number of connections, it is determined that the server is disconnected from the shared memory; wherein, the total number of connections is The number of connections to the shared memory in the normal log storage state;

If the client remains connected to the shared memory and the number of connections is not less than the preset total number of connections, it is determined that the server is not disconnected from the shared memory.
The method of claim 12, wherein the method further comprises:

When it is determined that the server is disconnected, send a reconnection request to the server according to a preset frequency;

When the server receives the reconnection request sent by the client, the server reconnects to the shared memory according to the reconnection request.
The method according to claim 13, wherein the registration success information includes an identification code assigned by the server to the client; the reconnection request includes the identification code; The reconnection request to reconnect with the shared memory includes:

The server connects to the shared memory according to the identification code in the reconnection request.
The method according to claim 1, wherein the server obtains the log information from the shared memory and stores it in a preset storage path, comprising:

The server obtains log information with a priority higher than a preset second printing level from the shared memory, and stores it in a preset storage path.
The method according to claim 15, wherein the printing level of the log information includes OFF level, FATAL level, ERROR level, WARN level, INFO level, DEBUG level, TRACE level in descending order of priority. And ALL level.
The method according to claim 15 or 16, wherein the server obtains the log information from the shared memory and stores it in a preset storage path, comprising:

The server obtains the log information from the shared memory in a single-threaded manner and stores it in a preset storage path.
The method according to claim 15 or 16, wherein the registration request includes an amount of memory to be occupied, and the application for shared memory for the client according to the registration request includes:

Determine the current remaining amount of memory on the server;

The server applies for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied.
The method according to claim 18, wherein the applying for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied comprises:

If the amount of memory to be occupied is less than the remaining amount of memory, apply for a shared memory corresponding to the amount of memory to be occupied for the client;

If the amount of memory to be occupied is not less than the remaining amount of memory, refuse to apply for shared memory for the client.
The method according to any one of claims 15-16, 19, wherein the registration request further includes the process identifier of the client;

Correspondingly, the applying for shared memory for the client according to the registration request includes:

Determine whether the process identifier is included in the preset process blacklist;

If it does not exist, apply for shared memory for the client;

If it exists, refuse to apply for shared memory for the client.
The method according to any one of claims 15-16, 19, wherein the registration request is generated according to a preset log writing configuration;

The applying for shared memory for the client according to the registration request includes:

The server applies for shared memory for the client according to the log writing configuration.
The method according to claim 21, wherein the log writing configuration includes at least one of a size of a memory to be occupied, a storage mode, a storage location, a storage subfolder division, and a storage subfolder size.
The method according to any one of claims 15-16, 19, and 22, wherein after applying for shared memory for the client according to the registration request, the method further comprises:

The server performs an initialization operation on the shared memory to obtain a lock-free queue instance.
The method according to any one of claims 15-16, 19, and 22, wherein after applying for shared memory for the client according to the registration request, the method further comprises:

The server performs an initialization operation on the shared memory to obtain a locked queue instance.
The method according to any one of claims 15-16, 19, 22, wherein after the server sends registration success information to the client, the method further comprises:

The server monitors the log writing status in the shared memory, and manages the client according to the monitoring result.
The method according to claim 25, wherein the server monitoring the log writing status in the shared memory, and managing and controlling the client according to the monitoring result, comprises:

The server determines whether the speed at which the client writes the log exceeds a preset speed threshold;

If yes, it is determined that the client is faulty.
The method according to claim 25, wherein the server monitoring the log writing status in the shared memory, and managing and controlling the client according to the monitoring result, comprises:

The server determines whether the number of logs written by the client exceeds a preset number threshold;

If yes, it is determined that the client is faulty.
The method according to claim 26 or 27, wherein after determining that the client has a fault, the method further comprises:

Determining, by the server, the authority information corresponding to the client according to the process identifier of the client;

The server manages and controls the log information written by the client according to the authority information.
The method according to claim 1, wherein the method comprises:

The server obtains the log information from the shared memory, and publishes the log information.
A log processing method applied to a client terminal, characterized in that the method includes:

Send a registration request to the server through the preset calling interface

When the registration success information fed back by the server is received, the log information of the client is written into the shared memory of the client and the server.
The method of claim 30, wherein the shared memory is a lock-free queue instance.
The method of claim 30, wherein the shared memory is a locked queue instance.
The method according to claim 30, wherein the registration request is sent by one of the threads of the client.
The method according to claim 33, wherein the writing the log information of the client into the shared memory comprises:

The log of each thread in the client is written into the shared memory according to a predetermined thread storage sequence.
The method according to any one of claims 30-34, wherein the writing the log information of the client into the shared memory comprises:

Store log information with a priority higher than the preset first printing level in the shared memory.
The method according to any one of claims 30-34, wherein the printing level of the log information includes OFF level, FATAL level, ERROR level, WARN level, INFO level, DEBUG level, TRACE level and ALL level.
The method according to any one of claims 30-34, wherein the writing the log information of the client into the shared memory comprises:

The log information of the client is written into the shared memory in an asynchronous storage manner.
The method according to claim 30, wherein the registration information further includes the process identifier of the process that sent the registration request.
The method according to claim 30, wherein before sending a registration request to the server through the calling interface preset by the client, the method further comprises:

The registration request is generated according to the preset log writing configuration.
The method according to claim 39, wherein the log writing configuration includes at least one of a size of a memory to be occupied, a storage mode, a storage location, a storage subfolder division, and a storage subfolder size.
The method according to any one of claims 30-34 and 38-39, wherein when the registration success information fed back by the server is received, the log information of the client is written into the shared After in memory, it also includes:

Acquiring the number of connections of the shared memory;

Determine whether the server is disconnected from the shared memory according to the number of connections.
The method of claim 41, wherein the determining whether the server is disconnected from the shared memory according to the number of connections comprises:

If the client remains connected to the shared memory, and the number of connections is less than the preset total number of connections, it is determined that the server is disconnected from the shared memory; wherein, the total number of connections is The number of connections to the shared memory in the normal log storage state;

If the client remains connected to the shared memory and the number of connections is not less than the preset total number of connections, it is determined that the server is not disconnected from the shared memory.
The method according to claim 42, wherein the method further comprises:

When it is determined that the server is disconnected, a reconnection request is sent to the server at a preset frequency.
The method according to claim 43, wherein the registration success information includes an identification code assigned by the server to the client; the reconnection request includes the identification code; and the identification code is used for The server can be connected to the shared memory according to the identification code in the reconnection request.
A log processing method applied to a server, wherein the method includes:

Receive the registration request sent by the client;

Apply for shared memory for the client according to the registration request;

After the shared memory application is successful, send registration success information to the client;

Obtain the log information of the client from the shared memory of the client and the server, and store it in a preset storage path.
The method of claim 45, wherein the obtaining the log information from the shared memory and storing it in a preset storage path comprises:

Obtain log information with a priority higher than the preset second printing level from the shared memory, and store it in a preset storage path.
The method according to claim 46, wherein the printing level of the log information includes OFF level, FATAL level, ERROR level, WARN level, INFO level, DEBUG level, and TRACE level in descending order of priority. And ALL level.
The method according to any one of claims 45-47, wherein the server acquiring the log information from the shared memory and storing it in a preset storage path comprises:

The server obtains the log information from the shared memory in a single-threaded manner and stores it in a preset storage path.
The method according to any one of claims 45-47, wherein the registration request includes an amount of memory to be occupied, and the application for shared memory for the client according to the registration request comprises:

Determine the current remaining amount of memory on the server;

Apply for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied.
The method according to claim 49, wherein the applying for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied comprises:

If the amount of memory to be occupied is less than the remaining amount of memory, apply for a shared memory corresponding to the amount of memory to be occupied for the client;

If the amount of memory to be occupied is not less than the remaining amount of memory, refuse to apply for shared memory for the client.
The method according to any one of claims 45-47 and 50, wherein the registration request further includes the process identifier of the client;

Correspondingly, the applying for shared memory for the client according to the registration request includes:

Determine whether the process identifier is included in the preset process blacklist;

If it does not exist, apply for shared memory for the client;

If it exists, refuse to apply for shared memory for the client.
The method according to any one of claims 45-47, wherein the registration request is generated according to a preset log writing configuration;

The applying for shared memory for the client according to the registration request includes:

Apply for shared memory for the client according to the log writing configuration.
The method according to claim 52, wherein the log writing configuration includes at least one of a size of a memory to be occupied, a storage mode, a storage location, a storage subfolder division, and a storage subfolder size.
The method according to any one of claims 45-47, 50, 53, wherein after applying for shared memory for the client according to the registration request, the method further comprises:

Perform an initialization operation on the shared memory to obtain a lock-free queue instance.
The method according to any one of claims 45-47, 50, 53, wherein after applying for shared memory for the client according to the registration request, the method further comprises:

Perform an initialization operation on the shared memory to obtain a locked queue instance.
The method according to any one of claims 45-47, 50, 53, wherein the method further comprises:

When receiving the reconnection request sent by the client, reconnect with the shared memory according to the reconnection request.
The method according to claim 56, wherein the registration success information includes an identification code allocated by the server to the client; the reconnection request includes the identification code; The reconnection request to reconnect with the shared memory includes:

Connect to the shared memory according to the identification code in the reconnection request.
The method according to any one of claims 45-47, 50, 53, 57, wherein after the sending the registration success information to the client, the method further comprises:

The log writing status in the shared memory is monitored, and the client is managed and controlled according to the monitoring result.
The method according to claim 58, wherein the monitoring the log writing status in the shared memory and managing and controlling the client according to the monitoring result comprises:

Determining whether the speed at which the client writes the log exceeds a preset speed threshold;

If yes, it is determined that the client is faulty.
The method according to claim 58, wherein the monitoring the log writing status in the shared memory and managing and controlling the client according to the monitoring result comprises:

Judging whether the number of logs written by the client exceeds a preset number threshold;

If yes, it is determined that the client is faulty.
The method according to claim 59 or 60, wherein after determining that the client is faulty, the method further comprises:

Determining the authority information corresponding to the client according to the process identifier of the client;

The log information written by the client is managed and controlled according to the authority information.
The method of claim 45, wherein the method further comprises:

Acquire the log information from the shared memory, and perform publishing processing on the log information.
A log processing system, characterized in that it comprises

One or more processors;

One or more memories;

The memory is used to store program codes;

The processor is used to call the program code, and when the program code is executed, it is used to perform the following operations:

Send a registration request to the server through the call interface preset by the client;

Receiving the registration request sent by the client through the server;

Apply for shared memory for the client through the server according to the registration request;

After the shared memory application is successful, send registration success information to the client through the server;

When receiving the registration success information fed back by the server, write the log information of the client into the shared memory through the client;

The log information is obtained from the shared memory through the server and stored in a preset storage path.
The log processing system according to claim 63, wherein the shared memory is a lock-free queue instance.
The log processing system according to claim 63, wherein the shared memory is a locked queue instance.
The log processing system according to claim 63, wherein the registration request is sent by one of the threads of the client.
The log processing system according to claim 66, wherein the processor is configured to: when writing the log information of the client into the shared memory through the client:

The log of each thread in the client is written into the shared memory through the client according to a predetermined thread storage sequence.
The log processing system according to any one of claims 63-67, wherein when the processor writes the log information of the client into the shared memory through the client, the processor is configured to:

The log information whose priority is higher than the preset first printing level is stored in the shared memory through the client.
The log processing system according to any one of claims 63-67, wherein the printing level of the log information includes OFF level, FATAL level, ERROR level, WARN level, INFO, which are arranged in descending order of priority. Level, DEBUG level, TRACE level and ALL level.
The log processing system according to any one of claims 63-67, wherein when the processor writes the log information of the client into the shared memory through the client, the processor is configured to:

The log information of the client is written into the shared memory through the client in an asynchronous storage manner.
The log processing system according to claim 63, wherein the processor is further configured to: before sending a registration request to the server through the calling interface preset by the client,

The registration request is generated by the client according to a preset log writing configuration.
The log processing system according to claim 71, wherein the log writing configuration includes at least one of a memory size to be occupied, a storage mode, a storage location, a storage subfolder division, and a storage subfolder size. Kind.
The log processing system according to any one of claims 63-67 and 71-72, wherein, when the processor receives the registration success information fed back by the server, the processor transmits all information through the client After the log information of the client is written into the shared memory, it is also used to:

Acquiring the number of connections of the shared memory through the client;

The client determines whether the server is disconnected from the shared memory according to the number of connections.
The log processing system according to claim 73, wherein the processor is configured to: when the client determines whether the server is disconnected from the shared memory according to the number of connections through the client:

If the client remains connected to the shared memory, and the number of connections is less than the preset total number of connections, the client determines that the server is disconnected from the shared memory; wherein, The total number of connections is the number of connections of the shared memory in the normal log storage state;

If the client maintains a connection with the shared memory, and the number of connections is not less than a preset total number of connections, it is determined by the client that the server is not disconnected from the shared memory.
The log processing system according to claim 74, wherein the processor is further configured to:

When it is determined that the server is disconnected, sending a reconnection request to the server through the client according to a preset frequency;

When the server receives the reconnection request sent by the client, the server reconnects to the shared memory according to the reconnection request.
The log processing system according to claim 75, wherein the registration success information includes an identification code assigned by the server to the client; the reconnection request includes the identification code; and the processor When reconnecting to the shared memory through the server according to the reconnection request, it is used to:

Connect to the shared memory through the server according to the identification code in the reconnection request.
The log processing system according to claim 63, wherein when the processor obtains the log information from the shared memory through the server and stores it in a preset storage path, it is configured to:

Obtain log information with a priority higher than a preset second printing level from the shared memory through the server, and store it in a preset storage path.
The log processing system according to claim 77, wherein the printing level of the log information includes OFF level, FATAL level, ERROR level, WARN level, INFO level, DEBUG level, TRACE level and ALL level.
The log processing system according to claim 77 or 78, wherein when the processor obtains the log information from the shared memory through the server and stores it in a preset storage path, it uses in:

The log information is obtained from the shared memory in a single-threaded manner through the server and stored in a preset storage path.
The log processing system according to claim 77 or 78, wherein the registration request includes an amount of memory to be occupied, and the processor applies for sharing for the client according to the registration request through the server. When the memory is used:

Determine the current remaining amount of memory on the server;

The server applies for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied.
The log processing system according to claim 80, wherein the processor is configured to use the server to apply for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied by the server. :

If the amount of memory to be occupied is less than the remaining amount of memory, apply for a shared memory corresponding to the amount of memory to be occupied for the client;

If the amount of memory to be occupied is not less than the remaining amount of memory, refuse to apply for shared memory for the client.
The log processing system according to any one of claims 77-78 and 81, wherein the registration request further includes a process identifier of the client;

Correspondingly, when applying for shared memory for the client through the server according to the registration request, the processor is configured to:

Determine whether the process identifier is included in the preset process blacklist;

If it does not exist, apply for shared memory for the client;

If it exists, refuse to apply for shared memory for the client.
The log processing system according to any one of claims 77-78 and 81, wherein the registration request is generated according to a preset log writing configuration;

When the processor applies for shared memory for the client according to the registration request through the server, it is configured to:

The server applies for shared memory for the client according to the log writing configuration.
The log processing system according to claim 83, wherein the log writing configuration includes at least one of a memory size to be occupied, a storage mode, a storage location, a storage subfolder division, and a storage subfolder size. Kind.
The log processing system according to any one of claims 77-78, 81, 84, wherein after the processor receives a registration request sent by the client through the server, the processor further comprises:

The server initializes the shared memory to obtain a locked queue instance.
The log processing system according to any one of claims 77-78, 81, 84, wherein after the processor receives a registration request sent by the client through the server, the processor further comprises:

The server initializes the shared memory to obtain a locked queue instance.
The log processing system according to any one of claims 77-78, 81, 84, wherein after the processor sends registration success information to the client through the server, further comprising:

The log writing status in the shared memory is monitored by the server, and the client is managed and controlled according to the monitoring result.
The log processing system according to claim 87, wherein when the processor monitors the log writing status in the shared memory through the server, and controls the client according to the monitoring result For:

The server determines whether the speed at which the client writes the log exceeds a preset speed threshold;

If yes, it is determined that the client is faulty.
The log processing system according to claim 87, wherein when the processor monitors the log writing status in the shared memory through the server, and controls the client according to the monitoring result For:

The server determines whether the number of logs written by the client exceeds a preset number threshold;

If yes, it is determined that the client is faulty.
The log processing system according to claim 88 or 89, wherein after determining that the client has a fault, the processor is further configured to:

Determining, by the server, the authority information corresponding to the client according to the process identifier of the client;

The server manages and controls the log information written by the client according to the authority information.
The log processing system according to claim 63, wherein the processor is configured to:

The server obtains the log information from the shared memory, and publishes the log information.
A client terminal device, characterized in that, the terminal device includes:

Memory and processor;

The memory is used to store program codes;

The processor calls the program code, and when the program code is executed, is used to perform the following operations:

Send a registration request to the server through the preset calling interface

When the registration success information fed back by the server is received, the log information is written into the shared memory of the client and the server.
The terminal device according to claim 92, wherein the shared memory is a lock-free queue instance.
The terminal device of claim 92, wherein the shared memory is a locked queue instance.
The terminal device according to claim 92, wherein the registration request is sent by one of the threads of the client.
The terminal device of claim 95, wherein the processor is configured to: when writing log information of the client into the shared memory:

The log of each thread in the client is written into the shared memory according to a predetermined thread storage sequence.
The terminal device according to any one of claims 92-96, wherein the processor is configured to: when writing log information of the client into the shared memory:

Store log information with a priority higher than the preset first printing level in the shared memory.
The terminal device according to any one of claims 92-96, wherein the printing level of the log information includes OFF level, FATAL level, ERROR level, WARN level, and INFO level in descending order of priority. , DEBUG level, TRACE level and ALL level.
The terminal device according to any one of claims 92-96, wherein the processor is configured to: when writing log information of the client into the shared memory:

The log information of the client is written into the shared memory in an asynchronous storage manner.
The terminal device according to claim 92, wherein the registration information further includes a process identifier of the process that sent the registration request.
The terminal device according to claim 92, wherein the processor is further configured to: before sending a registration request to the server through the calling interface preset by the client terminal:

The registration request is generated according to the preset log writing configuration.
The terminal device according to claim 101, wherein the log writing configuration includes at least one of a memory size to be occupied, a storage mode, a storage location, a storage subfolder division, and a storage subfolder size .
The terminal device according to any one of claims 92-96 and 100-101, wherein the processor writes the log information of the client when receiving the registration success information fed back by the server After being stored in the shared memory, it is also used for:

Acquiring the number of connections of the shared memory;

Determine whether the server is disconnected from the shared memory according to the number of connections.
The terminal device according to claim 103, wherein the processor is configured to: when determining whether the server is disconnected from the shared memory according to the number of connections:

If the client remains connected to the shared memory, and the number of connections is less than the preset total number of connections, it is determined that the server is disconnected from the shared memory; wherein, the total number of connections is The number of connections to the shared memory in the normal log storage state;

If the client remains connected to the shared memory and the number of connections is not less than the preset total number of connections, it is determined that the server is not disconnected from the shared memory.
The terminal device according to claim 104, wherein the processor is further configured to:

When it is determined that the server is disconnected, a reconnection request is sent to the server at a preset frequency.
The terminal device according to claim 105, wherein the registration success information includes an identification code allocated by the server to the client; the reconnection request includes the identification code; Therefore, the server can connect to the shared memory according to the identification code in the reconnection request.
A service terminal device, characterized in that, the service terminal device includes: a memory and a processor;

The memory is used to store program codes;

The processor calls the program code, and when the program code is executed, is used to perform the following operations:

Receive the registration request sent by the client;

Apply for shared memory for the client according to the registration request;

After the shared memory application is successful, send registration success information to the client;

Obtain the log information of the client from the shared memory and store it in a preset storage path.
The service terminal device according to claim 107, wherein when the processor obtains the log information from the shared memory and stores it in a preset storage path, it is configured to:

Obtain log information with a priority higher than the preset second printing level from the shared memory, and store it in a preset storage path.
The service terminal device according to claim 108, wherein the printing level of the log information includes OFF level, FATAL level, ERROR level, WARN level, INFO level, DEBUG level, TRACE level and ALL level.
The service terminal device according to any one of claims 107-109, wherein when the processor obtains the log information from the shared memory and stores it in a preset storage path, it is configured to:

The server obtains the log information from the shared memory in a single-threaded manner and stores it in a preset storage path.
The service terminal device according to any one of claims 107-109, wherein the registration request includes an amount of memory to be occupied, and when the processor applies for shared memory for the client according to the registration request For:

Determine the current remaining amount of memory on the server;

Apply for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied.
The service terminal device of claim 111, wherein the processor is configured to: when applying for shared memory for the client according to the remaining amount of memory and the amount of memory to be occupied, the processor is configured to:

If the amount of memory to be occupied is less than the remaining amount of memory, apply for a shared memory corresponding to the amount of memory to be occupied for the client;

If the amount of memory to be occupied is not less than the remaining amount of memory, refuse to apply for shared memory for the client.
The service terminal device according to any one of claims 107-109 and 112, wherein the registration request further includes a process identifier of the client;

Correspondingly, when applying for shared memory for the client according to the registration request, the processor is configured to:

Determine whether the process identifier is included in the preset process blacklist;

If it does not exist, apply for shared memory for the client;

If it exists, refuse to apply for shared memory for the client.
The service terminal device according to any one of claims 107-109, wherein the registration request is generated according to a preset log writing configuration;

When applying for shared memory for the client according to the registration request, the processor is configured to:

Apply for shared memory for the client according to the log writing configuration.
The service terminal device according to claim 114, wherein the log writing configuration includes at least one of a memory size to be occupied, a storage mode, a storage location, a storage subfolder division, and a storage subfolder size Kind.
The service terminal device according to any one of claims 107-109, 112, 115, wherein the processor is further configured to: after applying for shared memory for the client according to the registration request,

Perform an initialization operation on the shared memory to obtain a lock-free queue instance.
The service terminal device according to any one of claims 107-109, 112, 115, wherein the processor is further configured to: after applying for shared memory for the client according to the registration request,

Perform an initialization operation on the shared memory to obtain a locked queue instance.
The service terminal device according to any one of claims 107-109, 112, 115, wherein the processor is further configured to:

When receiving the reconnection request sent by the client, reconnect with the shared memory according to the reconnection request.
The service terminal device of claim 118, wherein the registration success information includes an identification code assigned by the server to the client; the reconnection request includes the identification code; and the processing When reconnecting to the shared memory according to the reconnection request, the device is used to:

Connect to the shared memory according to the identification code in the reconnection request.
The service terminal device according to any one of claims 107-109, 112, 115, and 119, wherein the processor is further configured to: after sending registration success information to the client terminal:

The log writing status in the shared memory is monitored, and the client is managed and controlled according to the monitoring result.
The service terminal device of claim 120, wherein the processor is configured to: when monitoring the log writing status in the shared memory, and controlling the client according to the monitoring result:

Determining whether the speed at which the client writes the log exceeds a preset speed threshold;

If yes, it is determined that the client is faulty.
The service terminal device of claim 120, wherein the processor is configured to: when monitoring the log writing status in the shared memory, and controlling the client according to the monitoring result:

Judging whether the number of logs written by the client exceeds a preset number threshold;

If yes, it is determined that the client is faulty.
The service terminal device according to claim 121 or 122, wherein, after determining that the client has a fault, the processor is further configured to:

Determining the authority information corresponding to the client according to the process identifier of the client;

The log information written by the client is managed and controlled according to the authority information.
The service terminal device of claim 107, wherein the processor is further configured to:

Acquire the log information from the shared memory, and perform publishing processing on the log information.
A computer-readable storage medium, characterized in that a computer program is stored thereon, and the computer program is executed by a processor to implement the method according to any one of claims 1-29 or 30-44 or 45-62 .