Method for transferring log data from an execution of a computer program

EP4466611A1Pending Publication Date: 2024-11-27ROBERT BOSCH GMBH
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
EP2022840774
Authority / Receiving Office
EP · EP
Patent Type
Applications
Current Assignee / Owner
Priority Date
2022-01-20
Filing Date
2022-12-28
Publication Date
2024-11-27

AI Technical Summary

Technical Problem

Existing methods for transmitting log data from computer program executions, particularly in safety-critical applications like vehicle control software, face challenges in efficiently handling flexible data structures with limited computing resources, leading to high transmission overhead and inefficient logging performance.

Method used

The method involves separating static and dynamic log data by generating an indexed list of user-defined log statement argument data types before execution, allowing for efficient transmission by sending static data beforehand and dynamic data separately, with deserialization occurring on the recipient side, reducing computational load on the sender.

Benefits of technology

This approach significantly enhances logging performance by minimizing data transfer and enabling flexible, structured logging, suitable for tracing and forensic analysis, while maintaining low computational effort on the sender, particularly in resource-constrained environments.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure 1.1
    Figure 1.1
Patent Text Reader

Abstract

The invention relates to various embodiments of a method for transferring log data from an execution of a computer program, the method comprising: generating an indexed list of identifiers of user-defined log-statement-argument data types; transferring, before the execution of the program, for each log statement of a set of log statements for outputting log data that is contained in the program, static log data to a log data receiver, the static log data being log data that remain the same for the log statement from execution to execution of the program; and transferring, when the program is executed, for each log statement of the set of log statements that is executed when the program is executed, dynamic log data for the log statement, the dynamic log data being log data that can change from execution to execution of the program, and the dynamic log data containing, if the log statement uses one of the user-defined log-statement-argument data types to output dynamic log data, an index of the identifier of the log-statement-argument data type.
Need to check novelty before this filing date? Find Prior Art

Description

[0001] Description

[0002] title

[0003] Method for transmitting log data of an execution of a computer program

[0004] State of the art

[0005] The present disclosure relates to methods for transmitting log data of an execution of a computer program.

[0006] Computer programs typically need to be checked for errors. This is especially true for control programs in safety-relevant applications, such as control software for a (possibly autonomous) vehicle. This is done by examining log data from the execution of a particular computer program. In certain applications, such as control software in a vehicle, it is desirable to be able to use flexible (e.g., user-defined) data structures for such log data while simultaneously minimizing the effort required by the sending side (here, the vehicle), for example, because it has limited computing resources.

[0007] Disclosure of the invention

[0008] According to various embodiments, a method for transmitting log data of an execution of a computer program is provided, comprising generating an indexed list of identifiers of user-defined log instruction argument data types, transmitting, before the execution of the program, for each log instruction of a set of log instructions for outputting log data contained in the program, static log data to a log data receiver, wherein the static log data is log data that remains the same for the log instruction from execution to execution of the program, and transmitting, during the execution of the program, for each log instruction of the set of log instructions that is executed during the execution of the program, dynamic log data for the log instruction, wherein the dynamic log data is log data that can change from execution to execution of the program, and wherein the dynamic log data,If the log statement uses one of the user-defined log statement argument data types to output dynamic log data, contains an index of the identifier of the log statement argument data type.

[0009] The method described above enables efficient transfer of log data (and thus efficient logging) by separating statistical and dynamic log data. This is especially true for user-defined log statement argument data types and thus for flexibly definable data types used for transferring log data (and structuring it).

[0010] Separating static and dynamic log data significantly increases logging performance. The use of custom log statement argument data types (also referred to simply as log data types) enables the logging of structured log data in this context. This can be used, for example, for tracing (for visualization and forensic reconstruction of program execution) using (downstream) deserialization.

[0011] Various examples of implementation are given below.

[0012] Embodiment 1 is the method described above for transmitting log data of an execution of a computer program.

[0013] Embodiment 2 is a method according to Embodiment 1, wherein, when the log instruction uses one of the user-defined log instruction argument data types to output dynamic log data, the dynamic log data includes raw data for the log instruction argument data type and an indication of the amount of raw data. In this way, the amount of raw data transmitted using a user-defined log instruction argument data type can be flexibly adjusted because it is part of the dynamic data for the log instruction argument data type (and is not statically determined).

[0014] Embodiment 3 is a method according to embodiment 1 or 2, comprising transmitting the dynamic log data via a communication channel, receiving the dynamic log data by the receiver, checking whether the dynamic log data contains an index of a log instruction argument data type if the dynamic log data contains an index of a log instruction argument data type, obtaining information about the log instruction argument data type, and converting the dynamic log data into a data structure according to the information about the log instruction argument data type. The conversion can be regarded as the actual deserialization of the user-defined log data. The checking, obtaining the information about the log instruction argument data type, and converting happen, for example, on the side of the receiver of the log data (e.g., a server and / or a cloud), which performs an analysis of the log data. The sender of the log data (e.g.,a vehicle), however, does not carry out this complex processing and writes the log data, e.g. one-to-one, into an archive (for later forwarding to the recipient).

[0015] In this way, a recipient (e.g. server or host that analyzes the log data and / or prepares it for a user) can correctly structure and further process the dynamic data (in particular raw data) transmitted for a log statement argument data type.

[0016] Embodiment 4 is a method according to embodiment 3, wherein the information about the log statement argument data type comprises labels of elements of the log statement argument data type.

[0017] This enables, for example, the raw data transmitted for a log statement argument data type to be displayed to a user with the correct labels. For example, in a visualization of the execution of the computer program, the log data can then be presented directly and hierarchically. Embodiment 5 is a method according to any one of embodiments 1 to 4, wherein the identifier of each log statement argument data type is a hash of a syntax tree of the log statement argument data type.

[0018] The use of such hashes allows for easy generation of unique identifiers.

[0019] Embodiment 6 is a method according to any one of embodiments 1 to 5, wherein the static log data is a location of the log instruction, a channel severity of a log message issued by the log instruction, and / or an argument layout of the log instruction.

[0020] This information does not change between program executions. By transmitting it in advance (e.g., to a server), the amount of log data transmitted during program execution can be reduced. The channel can, in particular, represent a severity level. Examples of channels are TIME, TRACE, EVENT, DEBUG, STATUS, INFO, WARNING, ERROR, and FATAL.

[0021] Embodiment 7 is a method according to one of the embodiments 1 to 6, wherein the log data types are classes of an object-oriented programming language.

[0022] This enables flexible structuring of the log data.

[0023] Embodiment 8 is a data processing arrangement which is configured to carry out a method according to one of the embodiments 1 to 7.

[0024] Embodiment 9 is a computer program including instructions that, when executed by one or more processors, cause the one or more processors to perform a method according to any one of embodiments 1 to 7.

[0025] Embodiment 10 is a computer-readable medium storing instructions that, when executed by one or more processors, cause the one or more processors to perform a method according to any one of embodiments 1 to 7. In the drawings, like reference numerals generally refer to the same parts throughout the several views. The drawings are not necessarily to scale, emphasis instead generally being placed upon illustrating the principles of the invention. In the following description, various aspects are described with reference to the following drawings.

[0026] Figure 1 shows a vehicle.

[0027] Figure 2 shows a recording system logging for software running on a control device in greater detail.

[0028] Figure 3 shows a linked list containing a chain of nodes starting from a list header.

[0029] Figure 4 shows a flowchart illustrating a method for transmitting log data of an execution of a computer program according to one embodiment.

[0030] The following detailed description refers to the accompanying drawings, which, by way of illustration, show specific details and aspects of this disclosure in which the invention may be practiced. Other aspects may be utilized, and structural, logical, and electrical changes may be made without departing from the scope of the invention. The various aspects of this disclosure are not necessarily mutually exclusive, as some aspects of this disclosure may be combined with one or more other aspects of this disclosure to form new aspects.

[0031] Various examples are described in more detail below.

[0032] Figure 1 shows a vehicle 101.

[0033] In the example of Figure 1, a vehicle 101, for example a car or truck, is provided with a vehicle control device (e.g., an Electronic Control Unit (ECU)) 102. The vehicle control device 102 has data processing components, e.g., a processor (e.g., a CPU (central processing unit)) 103 and a memory 104 for storing control software 107 according to which the vehicle control device 102 operates, and data processed by the processor 103.

[0034] For example, the stored control software (computer program) includes instructions which, when executed by the processor, cause the processor 103 to perform driver assistance functions (or collect driving data) or even control the vehicle autonomously.

[0035] In such a context, it is of great importance that errors in the control software 107 or in the execution of the control software 107 are detected reliably and quickly.

[0036] Therefore, according to various embodiments, it is provided that log data is generated during the execution of the control software 107 (e.g., "in the field," i.e., when the vehicle is on the move). These are, for example, first stored by the processor 103 in the memory 104 (e.g., RAM) and transmitted from there to a recording device 105. From there, they can then be transmitted to a server 108 via a network 106. In the case of the control software in a vehicle, the network 106 is a wireless network. In the case that the control software is provided in a control device of a stationary robot device (e.g., for an industrial robot arm), the network 106 is, for example, a wired network (e.g., an Ethernet).

[0037] The transfer of log data from the controller 102 (i.e., its memory 104) may be via a high data rate interface (e.g., PCIe (Peripheral Component Interconnect Express).

[0038] The log data can then be analyzed in various ways on the server 108. For example, the server 108 can use a trace to generate a representation of the execution of the control software 107 in the form of a Gantt chart, which includes, for example, activation points, execution duration, data flow, any (user) log messages for performance measurement, an algorithm-specific trace, etc.

[0039] Messages containing log data (also referred to as log information) generated and output by the processor during execution of the control software 107 include, for example:

[0040] • Text-based log messages with included or attached message arguments and severity (also called log level, e.g. fatal, error, warning, info, . . . )

[0041] • Trace messages with an included or attached trace context (data flow, execution order, . . . )

[0042] • Execution monitoring (profiling) messages with included or attached time context (time points, time span identifications)

[0043] • Events, possibly without any additional data included or attached (e.g. only an event identification)

[0044] • Marked payload messages (as in a measurement system)

[0045] The first four types of messages mentioned above are typically small and contain a static and a dynamic part. Messages of the last type (i.e., marked payload messages) can be very large (e.g., larger than 100 MB for special internal state data). However, for a holistic mechanism for analyzing log data, all types of data must be made available during logging and linked to a common temporal framework. This allows, for example, the respective developer to track and reproduce system behavior using special replay and (graphical) analysis tools.

[0046] Since a holistic mechanism is considered, “logging”, ie collecting log data, refers to both determining the log data (e.g. measuring) and recording it.

[0047] FIG. 2 shows a logging recording system 200 for software executing on a controller 201 in greater detail.

[0048] The control device 201 corresponds, for example, to the control device 107. It is connected via a PCIe bus 203 to a recording device 202, which corresponds, for example, to the recording device 105. For this purpose, the control device 201 and the recording device 202 have corresponding PCIe drivers 204 and PCIe interfaces 205.

[0049] The recording device 202 also has an Ethernet driver 206 and an Ethernet interface 207, for example, for communication with the server 108. As mentioned above, this can also be a wireless communication interface (with appropriate driver or communication software). Data transmission can take place via a "logger" (e.g., in the vehicle 101), which forwards the data to the server 108. The logger can, for example, be responsible for packaging the log data and transmitting it to the server 108 via a mobile connection.

[0050] The control device 201 can execute multiple processes 208 with multiple threads 209. The threads 209 produce log data, which the processor outputs in the form of log messages 212 and which (or their contents) are stored in a shared memory 210, which corresponds, for example, to the memory 104. A recording gateway 211 controls the transmission to the recording device 202. The recording device 202 has a recording bridge and / or a recording balancer 213, which controls the forwarding of log data to the server 108.

[0051] In order to enable the analysis of software 107 not only during its development phase but also during operation (e.g., as in the above example when it is run in the vehicle), it is desirable that the logging has the following properties:

[0052] • Freedom from interference (e.g. no synchronization to a common resource should occur, ie software threads 209 should be able to be logged independently of each other).

[0053] • Deterministic execution (e.g. no non-deterministic actions such as allocating heap memory are allowed)

[0054] • Reliable data transfer (i.e. no data should be lost, otherwise complete analysis is not possible)

[0055] The above requirements have significant implications for the design of the log mechanism, since the log messages 212 written by the threads 209 (i.e., by the processor) to the memory 210 should be as compact as possible so that they do not generate unnecessary runtime overhead and minimize runtime interference (even during process execution, the processes may output different amounts of log messages).

[0056] The recording system 200 decouples logging from the actual log data transport.

[0057] According to various embodiments, in order to keep the log messages 212 as small as possible, each log message 212 is split into a static part (i.e., static log data) and a dynamic part (i.e., dynamic log data). The static log data is collected at compile time of the software 107 (by the respective data processing device that performs the compilation). It is thus available before the software 107 is executed (i.e., before the main(.) function is executed, e.g., in the case of software written in C). This is done by forming a linked list at compile time, as shown in FIG. 3.

[0058] Figure 3 shows a linked list 300 which contains a chain of nodes 302 starting from a list header 301.

[0059] Each node 302 contains an identification, static log data and a pointer 303 to the subsequent node 302 (with the last node pointing to NULL 304).

[0060] The static log data contains all data that can be extracted from the software's source code without executing it. This means that at compile time, the respective data processing device performing the compilation goes through the software's source code and extracts the static log information contained in each log data output instruction (i.e., which is always the same when executing that instruction), appends a corresponding node 302 to the chain 302, and inserts the static log information into it.

[0061] Examples of such static log data of such an instruction (also called a “log instruction”) are:

[0062] • Severity (fatal, error, . . . )

[0063] • Location of the log statement (software component, function, file, line, . . . ) • Arguments of the log statement (argument list including argument names and argument type identifiers or a reference to an AST (Abstract Syntax Tree) that describes non-trivial argument layouts)

[0064] • Format string (for lazy-late generation of the message, ie for shifting the effort from the sender to the receiver side)

[0065] • Static context information if necessary

[0066] The static log data can be stored in advance, e.g., in the server 108. Then, to transmit a log message 212, only the associated dynamic log data needs to be transmitted.

[0067] The log statement can access all information created at compile time and transfer only the dynamic part (i.e., the dynamic log data). This is done, for example, using the C++ language paradigm "template meta-programming."

[0068] The dynamic log data only needs to contain the runtime part of the log message, such as

[0069] • the values ​​of the arguments of the log statement

[0070] • an identification of the message (as a reference to the static log data of the log statement).

[0071] • Runtime context information (such as the identification of thread 209 that executed the log statement)

[0072] Table 1 shows an example of static log data and dynamic log data for a log message output by a log statement. Table 1

[0073] Since, for example, an embedded real-time system cannot use dynamic (i.e., heap) memory, the data structures for the log data have fixed sizes (in particular, the data structures that contain the dynamic log data for a particular log message). This means that the number of arguments of a log statement must be limited.

[0074] In the example above, the “type” of an argument represents common types like int, float, etc.

[0075] However, according to various embodiments, support for user-defined ("custom", e.g., primitive) log statement argument data types (also known as log data types) is also added by mapping them to specific type identifiers. This is done by creating a type list at compile time (by the respective data processing device performing the compilation) and assigning each type (also at compile time) a type identifier (e.g., a hash in a type hash list, which can be specified by an associated hash index).

[0076] The hash is only required for user-defined (complex) data types. It represents a sort of checksum over the type definition and is used to access the abstract type description (e.g., from a pool of class information). Such a type description can describe any data type (not just the primitive data types directly supported by logging).

[0077] This is done, for example, by meta-programming (e.g., by C++ metaprogramming for a C++ type list in the pall of a software written in C++ 107).

[0078] The log statement argument data types can then be easily deserialized using a deserialization handler (on the receiving side). This means that the raw data output during the execution of a log statement that uses such a log argument data type can be converted into a data structure appropriate to the data type (which can change constantly, especially during a development process) using a deserialization tool. This can be used, for example, to appropriately output the content of a log message output by the log statement (e.g., to a console). This is also possible on embedded systems (despite the limitations regarding dynamic memory). However, nondeterministic serialization or even deserialization is not permitted on the embedded system (e.g., an ECU).

[0079] Custom log statement argument data types are useful for anonymously recording complex log data structures for later analysis. Deserialization of complex data structures at runtime is computationally intensive and is therefore, according to one embodiment, not performed in the controller 102, but rather performed externally, e.g., through a message extraction process performed by the server 108 (i.e., on the host side), which is only required when the log data is to be analyzed.

[0080] For a user-defined log argument data type, the static log data of a log statement contains a special log argument type identifier that indicates to the recipient of the log message output by the log statement (i.e., a respective log data sink such as the server 108) that the log argument data in the dynamic log data contained in the log message cannot be interpreted in a trivial manner, but type reflection is required.

[0081] Table 2 shows an example of static log data and dynamic log data for a log message output by a log statement, where the log statement uses a user-defined log argument data type.

[0082] Table 2

[0083] "User-defined type" here refers to the hash of the user-defined log statement argument data type (or its index in a list of hash values). The hash serves as an indicator of the log statement argument data type. The hash index can be used to access the list of hash values ​​in which the hash was stored at compile time. This allows for further optimization of the size of the data to be transferred.

[0084] To register a (complex) user-defined log data type, i.e., to cause it to be added to the type list and assigned a hash (with associated hash index), a registration instruction is inserted into software 107 (e.g., by the user who wishes to use the user-defined log data type). This ensures that the user-defined log data type is known to the system (in particular, the data processing device that compiles and creates the static log data) before the static log data is created (and stored in server 108).

[0085] Table 3 shows a program snippet in which a user-defined log data type is defined (“SimpleTraceObject”), registered using a registration statement (REGISTER LOG DATA TYPE) and used by a log statement (LOG INFO).

[0086] Table 3 Before the LOG INFO call, an instance of SimpleTraceObject can be created on the stack by

[0087] SimpleTraceObject traceObject; or auto traceObject = SimpleTraceObject{};

[0088] Table 4 shows an example of a log output generated by deserializing the resulting log message (assuming an output in JSON format). _

[0089] Table 4

[0090] The strings "activation_sequence_number," "activation_context_id," "execution time ns," and "data sequence numbers" come from (a pool of) type descriptions (e.g., class information) that are enriched when registering custom data types. The handle for each type description is the hash of the respective data type.

[0091] The registration of custom log statement argument data types uses a framework that defines the hash for the log argument data type (e.g., a class hash), which identifies the log argument data type, which in turn references the information of the log argument data type (e.g., class information).

[0092] This log argument data type information represents the type AST extracted from the program code during the software build process 107. This is done, for example, using a Clang intermediate representation or DWARF debug information generated by the compiler. The log argument data type information also contains, for example, ABI (Application Binary Interface) information (e.g., in the form of flags) that specify, for example, the byte order (endianness) or standard memory alignment used for the dynamic log data. The log argument data type information (e.g., class information) also contains the names of the data type contents, as shown in Table 4, such as "activation sequence number" in the above example.

[0093] According to various embodiments, a deserialization framework is used that provides tools and libraries for deserializing data streams containing raw C++ objects with a source ABI (i.e., captured directly from memory). It can be deserialized into any data format using a reflection mechanism. According to a target ABI, the data can also be converted back into raw C++ objects. This framework allows raw C++ data to be processed from memory without the need for serialization in the controller 102 (e.g., an embedded system) that converts the data into a common representation. In this way, sufficient throughput can be ensured when recording the log data. (The focus of the approach is on high data rates and loads and therefore on write optimization.)According to one embodiment, the deserialization framework uses so-called class info and ABI flags to describe data type (standard) layouts and class hashes to identify the data type layouts. Autonomy can be achieved by inserting this information into the deserialization recording stream in the respective log data sink (host, server).

[0094] As explained above, during registration, the hash (e.g., class hash) for each user-defined log data type is extracted at compile time. As a further optimization measure, the hash (which, for example, has four bytes) is assigned an index by which it can be looked up in a list added to the static log data, which is also created at compile time. In addition, information (e.g., class information) is generated for each log argument data type and made available either in the log data stream transmitted to the server 108 (e.g., using a readable store managed by separate middleware) or by adding it to the static log data. Table 5 shows corresponding program code for this. Table 5

[0095] Since the dynamic log data per log instruction is typically small (i.e., the objects each containing the dynamic log data for a log instruction are very small), they are accumulated before their (asynchronous) transfer (e.g., from memory 210 to recording gateway 211). One reason for this is that on modern hardware platforms, the transfer of memory contents typically occurs without copying, i.e., the memory contents are transferred using DMA (Direct Memory Access), whereby ownership of the respective memory areas (of memory 210) is immediately assumed.

[0096] However, such transfers are expensive (in terms of computational or signaling overhead) and are therefore not performed for each log message 212. Instead, using a memory-to-memory copy operation (e.g., memcpy) for the dynamic log data of individual log instructions is less expensive overall if the amount of dynamic log data (per log instruction), especially the dynamic log data for user-defined log instruction argument data types, is small.

[0097] According to one embodiment, each thread 209 thus has a dedicated stack-like data structure in shared memory 210, which is filled with dynamic log data during the execution of software 107. The log data is then transferred (e.g., after the respective thread or process terminates) by notifying the respective recipient (here, the recording gateway 211, which in turn initiates the asynchronous transfer). Overflow can be prevented by early notification and transfer.

[0098] Table 6 shows an example of such a stack-like data structure for a thread.

[0099] Table 6

[0100] Different priorities can be associated with the log data. For example, if a trace object is lost, recalculation may no longer be possible. Therefore, the log process can use prioritization functions provided by the respective interfaces and adapters to achieve log message prioritization.

[0101] In summary, according to various embodiments, a method is provided as shown in Figure 4.

[0102] Figure 4 shows a flowchart 400 illustrating a method for transmitting log data of an execution of a computer program according to one embodiment.

[0103] In 401, an indexed list of identifiers of user-defined log statement argument data types is created.

[0104] In 402, prior to execution of the program, static log data is transmitted to a log data receiver for each log instruction of a set of log instructions for outputting log data contained in the program, the static log data being log data that remains the same for the log instruction from execution to execution of the program.

[0105] In 403, during execution of the program, for each log statement of the set of log statements executed during execution of the program, dynamic log data for the log statement is transferred, wherein the dynamic log data is log data that can change from execution to execution of the program, and wherein the dynamic log data, if the log statement uses one of the user-defined log statement argument data types to output dynamic log data, contains an index of the identifier of the log statement argument data type.

[0106] The method of Figure 4 may be performed by one or more computers having one or more data processing units. The term "data processing unit" may be understood as any type of entity that enables the processing of data or signals. The data or signals may, for example, be processed according to at least one (i.e., one or more than one) specific function performed by the data processing unit. A data processing unit may comprise or be formed from an analog circuit, a digital circuit, a logic circuit, a microprocessor, a microcontroller, a central processing unit (CPU), a graphics processing unit (GPU), a digital signal processor (DSP), a programmable gate array (FPGA) integrated circuit, or any combination thereof.Any other way of implementing the respective functions described in more detail herein may also be understood as a data processing unit or logic circuit arrangement. One or more of the method steps described in detail herein may be performed (e.g., implemented) by a data processing unit through one or more specific functions performed by the data processing unit.

[0107] The approach of Figure 4 is used to monitor software. This could, for example, be control software for a robotic device. The term "robotic device" can be understood as referring to any technical system (with a mechanical part whose movement is controlled), such as a computer-controlled machine, a vehicle, a household appliance, a power tool, a manufacturing machine, a personal assistant, or an access control system. A control rule for the technical system is learned, and the physical system is then controlled accordingly. The software can, for example, run on an embedded system.Although specific embodiments have been illustrated and described herein, it will be recognized by those skilled in the art that the specific embodiments shown and described may be substituted for a variety of alternative and / or equivalent implementations without departing from the scope of the present invention. This application is intended to cover any adaptations or variations of the specific embodiments discussed herein. Therefore, it is intended that this invention be limited only by the claims and the equivalents thereof.

Claims

Claims 1. Method for transmitting log data from the execution of a computer program, comprising: Generating an indexed list of identifiers of user-defined log statement argument data types; Transmitted, prior to program execution, for each log instruction of a set of log instructions for outputting log data contained in the program, from static log data to a log data receiver, the static log data being such log data that remains the same for the log instruction from execution to execution of the program; and Upon execution of the program, dynamic log data for each log statement of the set of log statements executed during the execution of the program is transmitted, wherein the dynamic log data is such log data that can change from execution to execution of the program, and wherein, if the log statement uses one of the user-defined log statement argument data types to output dynamic log data, the dynamic log data includes an index of the identifier of the log statement argument data type.

2. The method of claim 1, wherein the dynamic log data, when the log instruction uses one of the user-defined log instruction argument data types to output dynamic log data, includes raw data for the log instruction argument data type and an indication of the amount of raw data.

3. A method according to claim 1 or 2, comprising transmitting the dynamic log data via a communication channel, receiving the dynamic log data by the receiver, and checking whether the dynamic log data contains an index of a log instruction argument data type. If the dynamic log data contains an index of a log statement argument data type, obtain information about the log statement argument data type and convert the dynamic log data into a data structure according to the information about the log statement argument data type. A method according to claim 3, wherein the information about the log statement argument data type includes labels of elements of the log statement argument data type. A method according to any one of claims 1 to 4, wherein the identifier of each log statement argument data type is a hash of a syntax tree of the log statement argument data type. A method according to any one of claims 1 to 5, wherein the static log data is a location of the log statement, a channel of a log message output by the log statement, and / or an argument layout of the log statement. Method according to any one of claims 1 to 6, wherein the log data types are classes of an object-oriented programming language.A data processing arrangement configured to perform a method according to any one of claims 1 to 7. A computer program with instructions which, when executed by one or more processors, cause the one or more processors to perform a method according to any one of claims 1 to 7. A computer-readable medium which stores instructions which, when executed by one or more processors, cause the one or more processors to perform a method according to any one of claims 1 to 7.