CN117742782B

CN117742782B - Log data cross-language automatic recording method and system for software system

Info

Publication number: CN117742782B
Application number: CN202410185088.2A
Authority: CN
Inventors: 孙梓轩; 罗玉波; 喻可伟; 胡敏; 余山海; 何东升; 李奎
Original assignee: Chengdu Jiuzhou Electronic Technology Co Ltd
Current assignee: Chengdu Jiuzhou Electronic Technology Co Ltd
Priority date: 2024-02-19
Filing date: 2024-02-19
Publication date: 2024-06-11
Anticipated expiration: 2044-02-19
Also published as: CN117742782A

Abstract

The invention discloses a method and a system for automatically recording log data of a software system in a cross-language manner, wherein the method comprises the following steps: registering a monitor to monitor event actions in the running process of the software system; introducing a log4cplus library to record event actions of the software system as log data and outputting the log data as a dynamic link library file and a static link library file; and registering a universal call interface by using the C++ language, and calling a dynamic link library file through the universal call interface to realize the check of log data. The invention can automatically record logs across multiple programming languages, effectively solves the limitation that the traditional log system can only run in a single language environment, can be widely applied to the multi-language programming environment, and improves the universality and adaptability of the system; the complexity and cost of the maintenance of the log recording system are obviously reduced, the efficiency and flexibility of the log recording are improved, and the complexity of the system maintenance is also reduced, so that powerful technical support is provided for the software development and maintenance.

Description

Log data cross-language automatic recording method and system for software system

Technical Field

The invention relates to the technical field of computer software, in particular to a method and a system for automatically recording log data in a cross-language manner for a software system.

Background

With the rapid development of information technology, software systems are increasingly used in various industries. Logging is an important step in the operation of software systems, which not only helps to monitor system status and behavior, but also is critical in analyzing and solving software problems. Traditional journaling methods rely primarily on specific programming languages or frameworks, which limit the flexibility and applicability of journaling. For example, traditional logging methods may not work effectively in concert when a software system spans multiple programming languages or platforms, resulting in incomplete or lost log information.

Currently, most mainstream development environments employ tangential plane programming (AOP) oriented techniques to implement logging. This approach is primarily involved in the front-end User Interface (UI) triggering the background services, monitoring event actions, capturing and recording system call behavior. The generated log is then persisted to a file system or database. While these approaches are effective in certain scenarios, they often exist as stand alone solutions, lack sufficient versatility and flexibility, and are difficult to meet the needs of cross-platform and multi-language environments.

In addition, these traditional logging methods typically involve high implementation costs and complex implementation paths, which result in high learning costs for the developer. Moreover, the methods exist independently, have no universality and cannot realize cross-platform language, so that repeated modification and customization of the log monitor are required under different service scenes, thereby increasing the maintenance cost and reducing the maintainability of the system. In addition, these approaches often lack the flexibility to support custom configurations, limiting their ability to adapt in a variety of complex environments.

Disclosure of Invention

In view of the above, there is a strong need for a method and system for automatically logging across languages in the daily operation of software to increase the flexibility and effectiveness of logging while reducing the complexity of system maintenance.

In order to achieve the technical purpose, the technical scheme provided by the invention comprises the following steps:

the method for automatically recording log data of a software system in a cross-language mode comprises the following steps:

S1, registering a monitor to monitor event actions in the running process of a software system;

s2, introducing a log4cplus library to record event actions of the software system as log data and outputting the log data as a dynamic link library file;

And S3, registering a general call interface by using a C++ language, and calling a dynamic link library file through the general call interface to realize the check of log data.

In some preferred embodiments, the listener listens for different types of software system event actions based on log level.

In some preferred embodiments, the method of writing the log4cplus library to log the event actions of the software system in step S2 includes:

S201, calling log4cplus to initialize a log system;

s202, creating a corresponding log recorder according to the number of log levels;

S203, recording log data by using a log recorder.

In some preferred embodiments, the method for registering a generic call interface using the c++ language in step S3 includes:

S301, determining a file path and a file name of a dynamic link library file, and recording an absolute path of the dynamic link library file;

s302, creating a corresponding relation between functions in a dynamic link library file and interface definition of a calling link;

S303, creating a binding or statement of the target language and the C++ language;

s304, at least one encapsulation layer defined by the interface is realized, and the encapsulation layer is used for converting the call of the high-level language into the call of the dynamic link library file function.

In some preferred embodiments, the method for viewing log data in step S3 includes:

the layout type, output format and corresponding log level of ConsoleAppender are configured in log4cplus, properties for outputting log data to the console;

Or, the log file name, maximum file size, number of backup files, output format and corresponding log level of RollingFileAppender are configured in log4cplus.

The invention also provides a log data cross-language automatic recording system for a software system, which comprises:

The monitoring module is configured to monitor the running condition of the software system;

The log recording module is used for configuring an integrated log4cplus library, recording the event actions of the software system as log data and outputting the log data as a dynamic link library file;

And the calling module is used for configuring a universal calling interface registered by using a C++ language and calling the dynamic link library file through the universal calling interface so as to realize the check of log data.

In some preferred embodiments, the snoop module listens for different types of software system event actions based on log level.

In some preferred embodiments, the logging module comprises:

an initialization sub-module, which is configured to call log4 cplus:initiate () to initialize the log system;

the log recorder submodule is configured to establish a corresponding log recorder according to the number of log levels;

And a data recording sub-module configured to record log data using the log recorder.

In some preferred embodiments, the calling module comprises:

The path sub-module is configured to determine a file path and a file name of the dynamic link library file and record an absolute path of the dynamic link library file;

An interface definition sub-module configured to create a correspondence with a function in the dynamic link library file and to invoke an interface definition of the link;

The language binding sub-module is configured to create a binding or statement of the target language and the C++ language;

And the encapsulation layer sub-module is configured to realize at least one encapsulation layer defined by using the interface so as to convert the call of the high-level language into the call of the dynamic link library file function.

In some preferred embodiments, the calling module further includes an output unit configured to provide different log data viewing modes; the output unit includes:

A console output subunit configured to configure ConsoleAppender in log4cplus, properties, layout type, output format, and corresponding log level to output log data to the console;

A file output subunit configured to configure RollingFileAppender the log file name, maximum file size, number of backup files, output format, and corresponding log level in log4cplus.

Advantageous effects

The invention can automatically record logs across multiple programming languages, effectively solves the limitation that the traditional log system can only run in a single language environment, can be widely applied to the multi-language programming environment, and improves the universality and adaptability of the system; the flexible management method of the log level is provided, so that a user is allowed to adjust the detail degree of the log record according to the needs, and different monitoring and debugging requirements can be met more accurately; the complexity and cost of the maintenance of the log recording system are obviously reduced, the efficiency and flexibility of the log recording are improved, and the complexity of the system maintenance is also reduced, so that powerful technical support is provided for the software development and maintenance.

Drawings

FIG. 1 is a flow chart of a method for automatically recording log data in a cross-language manner for a software system according to a preferred embodiment of the present invention;

FIG. 2 is a schematic diagram of a cross-language automatic log data recording system for a software system according to a preferred embodiment of the present invention;

Detailed Description

The present invention will be further described with reference to the accompanying drawings, in order to make the objects, technical solutions and advantages of the present invention more apparent. In the description of the present invention, it should be understood that the terms "upper," "lower," "front," "rear," "left," "right," "top," "bottom," "inner," "outer," and the like indicate or are based on the orientation or positional relationship shown in the drawings, merely to facilitate description of the present invention and to simplify the description, and do not indicate or imply that the system or element being referred to must have a particular orientation, be configured and operated in a particular orientation, and thus should not be construed as limiting the present invention.

As shown in fig. 1, the present embodiment provides a method for automatically recording log data in a cross-language manner for a software system, including the steps of:

S1, registering a monitor to monitor event actions in the running process of the software system. This step implements a listener registration mechanism that is responsible for recording the run-time conditions of the software at each moment in time when the software system is running, the information (thread, key variables, error location, time) of the error or crash encountered during its run-time; on the other hand, the running condition of the program at a certain moment or within a certain period of time can be tracked and recalled, so that the parameters such as the memory space consumed during the running of the software, the network consumption and the like are analyzed, and the problem of tracking and positioning codes is facilitated. This includes initializing listener instances, associating them with specific event types, and embedding into critical nodes of the system to capture events such as errors, warnings, user interactions, and system state changes. The listener design should ensure minimal performance overhead while providing real-time, accurate event capture functionality, thereby providing comprehensive visualization and diagnostic support for system operation.

In some preferred embodiments, the listener listens to software system event actions of different types according to log level, including but not limited to the following types of listens:

Not_set_log_level: accepting default LogLevel, inheriting its LogLevel if there is a parent logger;

all_log_level: open all log information output

TRACE_LOG_LEVEL: open trace information output

Debuglog LEVEL: open debug information output

Info_log_level: open info information output

Warn_log_level: open warning information output

ERROR LOG LEVEL: open error information output

FATAL_LOG_LEVEL: open fatal information output

Off_log_level: shutting down all log information outputs

S2, introducing a log4cplus library to record event actions of the software system as log data and outputting the log data as a dynamic link library file. This step achieves efficient log management functions by integrating log4cplus log libraries that are dedicated to capturing and formatting event actions of the software system, such as exceptions, operation requests, and other critical system events. Log4cplus can convert various events into detailed log data by defining the log levels and formats of the events. Further, the system compiles and encapsulates these log data into a Dynamic Link Library (DLL) file, ensuring independence and reusability of the logging modules, while providing cross-language and platform logging capabilities. In some preferred embodiments, the information is prioritized in a simple, multi-threaded, secure manner so that it can be oriented to the full lifecycle of program debugging, operation, testing, maintenance, etc.; the information can be selectively output to a database, a file, or even a remote server; regular backups of logs by making policies, and so on. Based on the cross-platform characteristic of C++ language, the log record system can be output as a dynamic link library, dll, and a static link library, lib file for supporting multiple development languages.

In some preferred embodiments, a method of writing log4cplus library is provided to record event actions of the software system as log data, comprising:

S201, calling log4cplus to initialize a log system;

S203, recording log data by using a log recorder.

The following process of writing a log in log4cplus involves several key concepts: logger (logger), appender (output target), layout (log Layout) as an example, the following example is given to illustrate a general writing step:

A. initializing a log system: at program start-up, log4cplus:: initiate () is required to initialize the log system

B. creation Logger: logger is an object for logging in log4cplus

#include

log4cplus::Logger logger = log4cplus::Logger::getInstance("MyLogger");

C. Logging using a logger, here using five log levels for logging, respectively

LOG4CPLUS_DEBUG(logger, "This is a debug message");

LOG4CPLUS_INFO(logger, "This is an info message");

LOG4CPLUS_WARN(logger, "This is a warning message"); LOG4CPLUS_ERROR(logger, "This is an error message");

LOG4CPLUS_FATAL(logger, "This is a fatal message");

D. cleaning up the resources, and cleaning up log4cplus resources when the program is finished

log4cplus::Logger::shutdown()。

And S3, registering a general call interface by using a C++ language, and calling a dynamic link library file through the general call interface to realize the check of log data. In particular, a series of generic call interfaces are implemented and registered in a C++ environment, which interfaces are designed specifically for interaction with a Dynamic Link Library (DLL). Through the carefully constructed universal interfaces, the system can activate and utilize functions in the DLL file, thereby realizing efficient viewing and management of log data. This process includes defining a standard interface protocol to ensure that the interface interfaces properly interface with the logging and viewing functions in the DLL. The calls to these generic interfaces are then implemented through standard C++ call mechanisms (e.g., function pointers or std:: function after C++ 11).

In some preferred embodiments, a generic method for registering a generic call interface in the C++ language is presented that includes:

At present, cross-platform development languages Java, C#, C++ all have methods for calling dll dynamic libraries, so the methods can be used for providing a logging solution for the development languages. The following further describes the calling method by taking a java platform as an example:

A. determining dll file paths

Before call dll dynamic library, first determine file path and file name, and record absolute path of file.

B. creating Java interfaces

In order to facilitate the interaction between Java codes and dll dynamic libraries, a Java interface needs to be created, and the corresponding relation between the Java codes and functions in the dll dynamic libraries and a call link are defined in the interface.

C. definition Native method

And defining a Native method in the interface for binding with the functions in the dll dynamic library. These methods are declared using the native key.

Public interface mydll{

void myfunction();

native void mydllFunction();

}

D. generating JNI header files

The command javah is used to generate a JNI header file that is used to define the link Java code and dll dynamic library.

Javah-ini com.exa.mydll

E. Native implementation method

And realizing a Native method in the generated JNI header file, and calling the function in the dll dynamic library through the JNI.

F. loading Native libraries

Native libraries are loaded in Java code to be able to call functions in dll dynamic libraries. The library file is loaded using the system.loadlibrary () method.

G. Compilation and operation

The code is compiled using a java compiler and the program is run.

Javac com/exa/Main.java

H. Initializing log listening components by configuration

In Java items, log initialization configuration is carried out in a configuration file, the Java items are initialized by using a function method in a JNI call dynamic library, and log4cplus can automatically initialize components. A reference count is maintained in Log4cplus: initializer class. The class may be instantiated multiple times. When this reference count reaches zero, log4cplus is automatically turned off after the last instance is destroyed.

The following further describes the calling method by taking the c# platform as an example:

A. A namespace is introduced:

At the top of the C# file, it is ensured that the necessary namespaces are introduced:

using System;

using System.Runtime.InteropServices;

B. Declaring an external function:

the DLL function outside is declared using DllImport attributes. Assume RecordEvent that the function follows the C call convention and accepts a string parameter:

class LogInterop

{

[DllImport("LogSystem.dll", CallingConvention = CallingConvention.Cdecl)]

public static extern int RecordEvent(string message);

}

C. Calling a function:

invoking RecordEvent the method, creating an instance and recording an event:

class Program

{

static void Main()

{

int status = LogInterop.RecordEvent("This is a test log message.");

if (status= 0)// assume 0 is a successful status code

{

Console.WriteLine("Event logged successfully.");

}

else

{

Console.WriteLine("Failed to log event.");

}

D. error handling and debugging:

Error handling is particularly important when handling external libraries. It is ensured that sufficient error handling and logging is added to facilitate debugging and runtime problem diagnosis.

E. and (3) testing:

before actual deployment, all possible inputs and environments are fully tested, ensuring the robustness of the code.

S201, calling log4cplus to initialize a log system;

S203, recording log data by using a log recorder.

Further, the embodiment also provides a method for viewing log data, which comprises the following steps:

In the following, examples are given by viewing logs in manners of console output, file output, integrating other log viewing tools with other custom viewing tools, and the like.

A. console output: one ConsoleAppender is configured in the configuration file and the log information is output to the console. This is useful for the debugging and development phases. The following are added to the log4cplus.

log4cplus.appender.console=log4cplus::ConsoleAppender log4cplus.appender.console.layout=log4cplus::PatternLayout log4cplus.appender.console.layout.ConversionPattern=%-5p [%c] - %m%n log4cplus.rootLogger=DEBUG, console

B. outputting a file: the log information is output to the file for later viewing. Log here is the name of the log file, maxFileSize and MaxBackupIndex define the size of the log file and the number of backup files, respectively. The following are added to the log4cplus.

log4cplus.appender.file=log4cplus::RollingFileAppender log4cplus.appender.file.File=logFile.log log4cplus.appender.file.MaxFileSize=5MB log4cplus.appender.file.MaxBackupIndex=1 log4cplus.appender.file.layout=log4cplus::PatternLayout log4cplus.appender.file.layout.ConversionPattern=%-5p [%c] - %m%n log4cplus.rootLogger=DEBUG, file

C. Integrating other log viewing tools: other Log viewing tools, such as tail, grep, etc., command line tools, or graphical Log viewing tools, such as Log4View, chainsaw, etc., may also be used. These tools typically support viewing and filtering logs from files in real-time

D. Custom viewing tool: an own log viewing tool can be written, log files generated by log4cplus can be read or connected to a log server through a network, and then log information can be displayed in a required mode.

As shown in fig. 2, the present embodiment further provides a log data cross-language automatic recording system for a software system, the system comprising:

In some preferred embodiments, the logging module comprises:

In some preferred embodiments, the calling module comprises:

A language binding sub-module configured to create a language binding or declaration for a language that can interact with c++, or to directly include a header file for a language that is c++ or compatible with c++;

In some preferred embodiments, the calling module further includes an output unit configured to provide different log data viewing modes;

The output unit includes:

The foregoing has shown and described the basic principles, principal features and advantages of the invention. It will be understood by those skilled in the art that the present invention is not limited to the embodiments described above, and that the above embodiments and descriptions are merely illustrative of the principles of the present invention, and various changes and modifications may be made without departing from the spirit and scope of the invention, which is defined in the appended claims. The scope of the invention is defined by the appended claims and equivalents thereof.

Claims

1. A method for cross-language automatic logging of log data for a software system, comprising the steps of:

s3, registering a general call interface by using a C++ language, and calling a dynamic link library file through the general call interface to realize the check of log data;

the monitor monitors event actions of the software system in different types according to the log level;

the method for registering the universal call interface by using the C++ language in the step S3 comprises the following steps:

2. The method for cross-language automatic recording of log data for a software system according to claim 1, wherein the method for writing log4cplus library to record event actions of the software system as log data in step S2 comprises:

S201, calling log4cplus to initialize a log system;

S203, recording log data by using a log recorder.

3. The method for cross-language automatic recording of log data for a software system according to claim 1, wherein the method for viewing log data in step S3 comprises:

4. A log data cross-language automatic recording system for a software system, the system comprising:

The calling module is used for configuring a universal calling interface registered by using a C++ language and calling a dynamic link library file through the universal calling interface so as to realize the check of log data;

the monitoring module monitors event actions of the software system in different types according to the log level;

The calling module comprises:

5. The log data cross-language automatic recording system for a software system of claim 4, wherein the log recording module comprises:

6. The system for cross-language automatic logging of log data for a software system of claim 4, wherein said calling module further comprises an output unit configured to provide different manners of viewing log data; the output unit includes: