Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. An event-message generation and transmission subsystem within a distributed computer system, the event-message generation and transmission subsystem comprising: one or more processors; one or more memories; a communications subsystem; and computer instructions, stored in one or more of the one or more memories that, when executed by one or more of the one or more processors, control the event-message generation and transmission subsystem to generate, by application-level functionality within distributed-computer-system components, a long event message that, were the long event message packaged in a single syslog message, would form a syslog message with a length that exceeds a specified syslog supported message length, package, by the application-level functionality within the distributed-computer-system components, the long event message into two or more component syslog messages, transmit the component syslog messages from the application-level functionality within distributed-computer-system components to an administration computer system through the syslog-messaging subsystem, receive the component syslog messages by application-level functionality within the administration computer system, and generate the long event message from the received component syslog messages by the application-level functionality within the administration computer system.
In distributed computer systems, event messages often exceed the maximum length supported by syslog protocols, leading to truncation or loss of critical diagnostic information. This invention addresses the problem by providing a subsystem that generates, packages, and transmits long event messages in a way that ensures complete delivery. The subsystem includes processors, memory, and a communications subsystem, along with instructions to handle long event messages. When an event message is too long to fit into a single syslog message, the system splits it into multiple smaller component syslog messages. These components are transmitted to an administration computer system, where they are reassembled into the original long event message. The packaging and reassembly processes are performed at the application level within the distributed system components and the administration system, ensuring compatibility with existing syslog infrastructure while preserving the integrity of long event messages. This approach prevents data loss and enables accurate logging and monitoring of system events.
2. The event-message generation and transmission subsystem of claim 1 wherein the application-level functionality within a distributed-computer-system component generates a unique message identifier for each event message generated and transmitted by the distributed-computer-system component.
In distributed computing systems, tracking and managing event messages is critical for debugging, monitoring, and coordination between system components. A challenge arises in ensuring that event messages can be uniquely identified across the system, especially in large-scale or dynamic environments where multiple components generate and transmit messages. This can lead to difficulties in correlating events, debugging issues, and maintaining system reliability. To address this, a subsystem generates and transmits event messages within a distributed computing environment. The subsystem includes functionality that assigns a unique message identifier to each event message created by any component in the system. This identifier ensures that every message can be distinctly recognized, even if multiple components generate similar or identical messages. The unique identifiers facilitate accurate tracking, correlation, and debugging of events across the distributed system. By embedding these identifiers within the messages, the system improves traceability, reduces ambiguity in event processing, and enhances overall system observability. This approach is particularly useful in complex distributed architectures where message volume is high and manual tracking is impractical. The unique identifiers may be generated using algorithms that guarantee uniqueness, such as timestamps, UUIDs, or other deterministic methods, ensuring no collisions occur even in high-throughput scenarios. This solution supports reliable event-driven workflows and improves system resilience by enabling precise event reconstruction and analysis.
3. The event-message generation and transmission subsystem of claim 1 wherein the application-level functionality within the distributed-computer-system components packages a short event message into a single syslog message with a length that is less than or equal to a specified syslog supported message length; and wherein the application-level functionality within the distributed-computer-system components packages a long event message that, were the long event message packaged in a single syslog message, would form a syslog message with a length that exceeds a specified syslog supported message length, into two or more component syslog messages.
In distributed computing systems, event messages generated by applications often exceed the length limits imposed by syslog protocols, leading to truncation or loss of critical diagnostic information. This invention addresses the problem by providing a method for efficiently packaging event messages into syslog-compliant messages without data loss. The system includes an event-message generation and transmission subsystem that processes both short and long event messages. For short messages, the subsystem packages them into a single syslog message, ensuring the total length does not exceed the supported syslog message length. For longer messages that would otherwise exceed this limit if packaged as a single syslog message, the subsystem splits the message into two or more component syslog messages. Each component message is transmitted separately, allowing the original long event message to be reconstructed at the receiving end. This approach ensures all event data is preserved while adhering to syslog constraints, improving system monitoring and troubleshooting capabilities. The solution is implemented at the application level within distributed system components, ensuring compatibility with existing syslog infrastructure.
4. The event-message generation and transmission subsystem of claim 3 wherein a single syslog message packaging a short event message comprises: a syslog-message prefix; an application-level message identifier; and the short event message.
This invention relates to a system for generating and transmitting event messages in a computing environment, particularly for efficiently packaging and transmitting short event messages using syslog protocols. The problem addressed is the need for a standardized, compact, and efficient way to transmit event messages in distributed systems, ensuring minimal overhead while maintaining traceability and debugging capabilities. The system includes a subsystem for generating and transmitting event messages, where a single syslog message is used to package a short event message. The syslog message includes a syslog-message prefix, an application-level message identifier, and the short event message itself. The syslog-message prefix contains metadata such as timestamps, source identifiers, or severity levels, while the application-level message identifier uniquely identifies the type or source of the event. The short event message is a concise representation of the event, optimized for transmission efficiency. This approach ensures that event messages are structured in a way that allows for easy parsing, filtering, and analysis while minimizing the data payload. The use of a standardized syslog format ensures compatibility with existing logging and monitoring systems, while the inclusion of an application-level identifier allows for precise event categorization and tracking. The system is particularly useful in environments where event logging must be both lightweight and informative, such as in cloud computing, distributed systems, or real-time monitoring applications.
5. The event-message generation and transmission subsystem of claim 4 wherein the single syslog message packaging a short event message further comprises: a long-event-message-indication field that indicates that the single syslog message contains an entire event message.
This invention relates to event-message generation and transmission in networked systems, particularly for handling long event messages that exceed the standard syslog message size limit. The problem addressed is the inefficiency and complexity of splitting long event messages into multiple syslog messages, which can lead to message fragmentation, loss, or misordering during transmission. The solution involves a subsystem that packages a short event message into a single syslog message, where the message includes a long-event-message-indication field. This field explicitly signals that the single syslog message contains the entire event message, eliminating the need for fragmentation. The subsystem ensures that even long event messages are transmitted as a single, self-contained syslog message, improving reliability and simplifying message processing. The approach avoids the overhead and potential errors associated with splitting and reassembling messages while maintaining compatibility with existing syslog protocols. This method is particularly useful in environments where event messages may vary in length and where message integrity is critical.
6. The event-message generation and transmission subsystem of claim 3 wherein a component syslog message containing a portion of a long event message comprises: a syslog-message prefix; an application-level message identifier; an [X−Y] field; and the portion of the long event message.
This invention relates to a system for generating and transmitting event messages, particularly for handling long event messages that exceed standard message length limits. The problem addressed is the difficulty in transmitting large event messages through systems that enforce strict message size constraints, such as syslog protocols, which often truncate or discard oversized messages. The subsystem processes long event messages by breaking them into smaller portions and embedding each portion within a syslog message. Each syslog message includes a prefix, an application-level message identifier, an [X−Y] field indicating the portion's position within the original long message, and the actual message portion. The prefix ensures compatibility with syslog standards, while the identifier and [X−Y] field enable reassembly of the full message at the receiving end. This approach ensures that no data is lost due to size limitations, allowing complete event messages to be reconstructed accurately. The system is particularly useful in environments where real-time monitoring and logging require the transmission of detailed event data without truncation.
7. The event-message generation and transmission subsystem of claim 6 wherein the component syslog message containing a portion of a long event message further comprises: a long-event-message-indication field that indicates that the component syslog message contains a portion of an event message.
This invention relates to a system for generating and transmitting event messages, particularly for handling long event messages that exceed standard message size limits. The system addresses the challenge of transmitting large event data in environments where message size constraints exist, such as in syslog-based logging systems. The subsystem generates component syslog messages, each containing a portion of a long event message, to ensure the entire message is transmitted without exceeding size restrictions. Each component syslog message includes a long-event-message-indication field, which signals that the message is part of a fragmented long event. This field allows the receiving system to identify and reassemble the fragmented messages into the original long event. The subsystem ensures reliable transmission by managing the segmentation and reassembly process, enabling systems to handle large event data efficiently while maintaining compatibility with existing syslog protocols. The invention improves event logging in distributed systems, cloud environments, and other scenarios where large event data must be transmitted reliably.
8. The event-message generation and transmission subsystem of claim 6 wherein the [X−Y] field in a component syslog message containing a portion of a long event message includes: a value X that represents a sequence number for the portion of the long event message event-message; and a value Y that represents a total number of event-message portions transmitted in Y syslog messages that together contain the entire long event message.
This invention relates to a system for generating and transmitting long event messages in a networked environment, particularly where individual messages exceed the maximum size allowed by standard syslog protocols. The problem addressed is the inability of traditional syslog systems to handle large event messages, which are often truncated or lost due to size limitations. The solution involves breaking long event messages into smaller portions, each transmitted as a separate syslog message, while preserving the ability to reconstruct the original message. The subsystem generates component syslog messages, each containing a portion of the long event message. Each component message includes an [X−Y] field, where X is a sequence number indicating the position of the portion within the full message, and Y is the total number of portions required to reconstruct the entire message. This allows receiving systems to identify and reassemble the portions in the correct order. The subsystem ensures that all portions are transmitted reliably, even if network conditions or syslog constraints would otherwise prevent the full message from being sent intact. The invention improves event logging in distributed systems by enabling the transmission of large, untruncated event data while maintaining compatibility with existing syslog infrastructure.
9. The event-message generation and transmission subsystem of claim 1 wherein the application-level functionality within the administration computer system unpackages a portion of a long event message from a received component syslog message by: storing the portion of the long event message contained in the component syslog message for subsequent forwarding to the higher-level functionality at the application level.
This invention relates to a system for handling long event messages in a distributed computing environment, particularly where event messages exceed the size limits of standard syslog protocols. The problem addressed is the inability of traditional syslog systems to transmit large event messages in a single transmission, leading to truncation or loss of critical event data. The system includes an event-message generation and transmission subsystem that processes and forwards event messages between different components of a computer system. When a long event message is generated, it is divided into smaller portions, each encapsulated within a standard syslog message format. These component syslog messages are then transmitted individually to an administration computer system. Within the administration computer system, application-level functionality receives these component syslog messages. Instead of immediately processing the event data, the system stores each portion of the long event message contained in the component syslog messages. These stored portions are later reassembled and forwarded to higher-level application functionality for complete event processing. This ensures that the entire long event message is preserved and available for analysis, even when transmitted in multiple smaller syslog messages. The system thus enables reliable transmission and reconstruction of large event messages in environments where standard syslog protocols would otherwise truncate or discard them.
10. The event-message generation and transmission subsystem of claim 9 wherein, when the received component syslog message is the first component syslog message for the long event message, the application-level functionality within the administration computer system stores the portion of the long event message by: allocating a buffer for the long event message; associating the buffer with a combination of the contents of an application-level message identifier contained in the component syslog message and a hostname contained in a syslog-prefix field within the component syslog message; adding the syslog-prefix field of the received component syslog message to the buffer; and storing the portion of the long event message at an offset within the buffer determined by a sequence number X contained in an [X−Y] field within the syslog message.
This invention relates to a system for generating and transmitting long event messages in a distributed computing environment, particularly where individual event messages exceed the size limits of standard syslog protocols. The problem addressed is the fragmentation of large event messages into smaller component syslog messages, which must be reassembled accurately at the receiving end. The subsystem handles the initial component syslog message of a fragmented long event by allocating a dedicated buffer in memory. The buffer is uniquely identified using a combination of an application-level message identifier and a hostname extracted from the syslog-prefix field of the incoming message. The syslog-prefix field is then stored in the buffer, and the event data payload is written to a specific offset within the buffer, determined by a sequence number (X) found in an [X−Y] field of the syslog message. This ensures proper reconstruction of the long event message by maintaining the correct order and positioning of each component message fragment. The system supports efficient storage and retrieval of fragmented event data, enabling accurate reconstruction of large event logs in administrative systems.
11. The event-message generation and transmission subsystem of claim 9 wherein, when the received component syslog message is not the first component syslog message received that contains a portion of the long event message, the application-level functionality within the administration computer system stores the portion of the long event message by: identifying a buffer for the long event message using a combination of the contents of an application-level message identifier contained in the component syslog message and a hostname contained in a syslog-prefix field within the component syslog message; and storing the portion of the long event message at an offset within the buffer determined by a sequence number X contained in an [X−Y] field within the component syslog message.
This invention relates to a system for generating and transmitting event messages in a distributed computing environment, particularly for handling long event messages that exceed the size limits of standard syslog messages. The problem addressed is the fragmentation of long event messages into smaller component syslog messages, which can lead to incomplete or disorganized event data when reassembled. The system includes an event-message generation and transmission subsystem that processes component syslog messages containing portions of a long event message. When a component syslog message is received, the subsystem checks if it is the first portion of the long event message. If not, the subsystem stores the portion in a buffer. The buffer is identified using a combination of an application-level message identifier from the component syslog message and a hostname from a syslog-prefix field. The portion is stored at a specific offset within the buffer, determined by a sequence number X from an [X−Y] field in the component syslog message. This ensures that fragmented event messages are correctly reassembled in the proper order. The system supports efficient handling of large event data by dynamically managing buffer allocation and sequence-based storage.
12. The event-message generation and transmission subsystem of claim 9 wherein, when the received component syslog message is the last component syslog message received that contains a portion of the long event message, the application-level functionality within the administration computer system forwards the syslog message contained in the buffer to higher-level functionality at the application level and deallocates the buffer.
This invention relates to a system for generating and transmitting event messages in a distributed computing environment, particularly for handling long event messages that exceed the size limits of standard syslog messages. The problem addressed is the fragmentation of large event messages into smaller syslog messages, which can lead to incomplete or lost data when transmitted across a network. The system includes a buffer for storing portions of a long event message received as multiple component syslog messages. An application-level functionality within an administration computer system monitors the incoming syslog messages to determine whether a received component syslog message is the last portion of the long event message. When the last component syslog message is received, the system forwards the complete syslog message stored in the buffer to higher-level application functionality for further processing. After forwarding, the buffer is deallocated to free up resources. The system ensures that long event messages are reassembled correctly before being processed, preventing data loss and maintaining message integrity. The buffer management and deallocation process optimizes system resources by releasing memory once the message is fully reconstructed and transmitted. This approach is particularly useful in environments where event logging and monitoring require the transmission of large, fragmented messages.
13. A method for transmitting long event messages from a first application-level entity to a second application-level entity within a distributed computer system, the method comprising: generating, by application-level functionality within the first entity, a long event message that, were the long event message packaged in a single syslog message, would form a syslog message with a length that exceeds a specified syslog supported message length, packaging, by the application-level functionality within the first entity, the long event message into two or more component syslog messages, transmitting the component syslog messages from the first entity to the second entity through a syslog-messaging subsystem, receiving the component syslog messages by the second entity, and unpackaging the long event message from the received component syslog messages by the second entity.
In distributed computer systems, application-level entities often need to transmit long event messages, but syslog messaging systems have strict length limitations. This can prevent the transmission of detailed event data, leading to incomplete logging and monitoring. The invention addresses this by enabling the fragmentation and reassembly of long event messages within the application layer, ensuring they can be transmitted via syslog without exceeding length constraints. The method involves an application-level entity generating a long event message that, if sent as a single syslog message, would exceed the supported message length. Instead, the application-level functionality splits the message into two or more smaller component syslog messages, each within the allowed length. These components are then transmitted through the syslog-messaging subsystem to a second application-level entity. Upon receipt, the second entity reassembles the original long event message from the component messages. This approach ensures that long event data is preserved while complying with syslog constraints, improving logging accuracy and system monitoring capabilities. The fragmentation and reassembly processes are handled entirely within the application layer, avoiding modifications to the underlying syslog infrastructure.
14. The method of claim 1 wherein first entity generates a unique message identifier for each event message generated and transmitted by the distributed-computer-system component.
This invention relates to distributed computer systems and addresses the challenge of uniquely identifying event messages generated and transmitted by system components. In such systems, multiple components generate and exchange event messages, but ensuring each message is uniquely identifiable is critical for tracking, debugging, and maintaining data integrity. The invention provides a solution by having a first entity in the system generate a unique message identifier for each event message produced and transmitted by any component of the distributed computer system. This identifier ensures that each message can be distinctly tracked across the system, preventing conflicts or ambiguities in message processing. The unique identifiers may be generated using algorithms, timestamps, or other methods to guarantee uniqueness. This approach enhances system reliability, simplifies troubleshooting, and improves message routing and logging. The invention is particularly useful in large-scale distributed systems where message volume is high, and ensuring traceability is essential. By assigning unique identifiers to every event message, the system can maintain accurate records, detect duplicates, and ensure proper message handling. The method supports scalability and interoperability across different system components, making it a robust solution for distributed computing environments.
15. The method of claim 1 wherein the application-level functionality within the distributed-computer-system components packages a short event message into a single syslog message with a length that is less than or equal to a specified syslog supported message length; and wherein the application-level functionality within the distributed-computer-system components packages a long event message that, were the long event message packaged in a single syslog message, would form a syslog message with a length that exceeds a specified syslog supported message length, into two or more component syslog messages.
In distributed computer systems, logging event data is essential for monitoring, debugging, and security. However, syslog, a widely used logging protocol, has limitations on message length, which can cause truncation or loss of critical event details. This invention addresses this problem by providing a method for efficiently packaging event messages into syslog-compliant logs without losing data. The method involves application-level functionality within distributed system components that processes both short and long event messages. For short event messages, the system packages them into a single syslog message, ensuring the total length does not exceed the supported syslog message length. For long event messages, which would otherwise exceed the syslog length limit if packaged as a single message, the system splits them into two or more component syslog messages. Each component message is formatted to comply with syslog length constraints while preserving the integrity of the original long event message. This ensures that all event data is logged correctly, even when individual events exceed syslog size limits. The approach maintains compatibility with existing syslog infrastructure while preventing data loss.
16. The method of claim 3 wherein a single syslog message packaging a short event message comprises: a syslog-message prefix; an application-level message identifier; the short event message; and a long-event-message-indication field that indicates that the single syslog message contains an entire event message.
This invention relates to syslog message formatting for event logging in computing systems. The problem addressed is the inefficiency of traditional syslog implementations when handling both short and long event messages, which can lead to fragmented logging or excessive resource usage. The method involves packaging a short event message within a single syslog message, which includes a syslog-message prefix, an application-level message identifier, the short event message itself, and a long-event-message-indication field. The long-event-message-indication field serves as a flag to indicate that the entire event message is contained within this single syslog message, distinguishing it from cases where multiple messages might be required for longer events. The syslog-message prefix contains standard syslog header information, such as timestamp, hostname, and facility information. The application-level message identifier uniquely identifies the type of event being logged, allowing for easier categorization and filtering. The short event message is the actual log content, while the long-event-message-indication field ensures that the receiving system knows the message is complete and does not need to wait for additional fragments. This approach improves logging efficiency by reducing the overhead of handling fragmented messages while maintaining compatibility with existing syslog infrastructure. It is particularly useful in environments where both short and long event messages must be processed reliably.
17. The method of claim 3 wherein a component syslog message containing a portion of a long event message comprises: a syslog-message prefix; an application-level message identifier; an [X−Y] field; the portion of the long event message; and a long-event-message-indication field that indicates that the syslog message contains a portion of an event message.
This invention relates to systems for handling long event messages in syslog-based logging environments. The problem addressed is the limitation of syslog messages to a fixed maximum length, which prevents the transmission of detailed or verbose event data. The solution involves splitting long event messages into multiple syslog messages while maintaining their logical coherence. The method processes a long event message by dividing it into portions, each encapsulated in a syslog message. Each portion includes a syslog-message prefix, an application-level message identifier to correlate the fragments, an [X−Y] field indicating the sequence position (e.g., X/Y where X is the current fragment and Y is the total fragments), the message portion itself, and a long-event-message-indication field to signal that the message is part of a longer event. The prefix ensures compatibility with standard syslog protocols, while the identifier and sequence fields enable reassembly of the original message. This approach allows systems to handle detailed event data without exceeding syslog length constraints while preserving message integrity.
18. The method of claim 17 wherein the [X−Y] field in a component syslog message containing a portion of a long event message includes: a value X that represents a sequence number for the portion of the long event message event-message; and a value Y that represents a total number of event-message portions transmitted in Y syslog messages that together contain the entire long event message.
This invention relates to the field of syslog message handling, specifically for managing long event messages that exceed the size limits of standard syslog messages. The problem addressed is the fragmentation and reassembly of long event messages in syslog systems, where individual messages are often limited in size, leading to incomplete or lost data when events exceed these constraints. The method involves encoding a field within a syslog message to track the sequence and total number of fragments for a long event message. The field, denoted as [X−Y], includes two values: X represents the sequence number of the current message portion, and Y represents the total number of portions that together form the complete long event message. This allows receiving systems to identify and reassemble the fragments in the correct order, ensuring the entire event message is reconstructed accurately. The method ensures that even if messages are transmitted out of order or lost, the system can detect missing portions and request retransmission. This approach improves reliability in event logging systems where message fragmentation is necessary due to size limitations.
19. The method of claim 1 wherein the second entity unpackages a portion of a long event message from a received component syslog message by: storing the portion of the long event message contained in the received component syslog message for subsequent forwarding to the higher-level functionality at the application level.
This invention relates to systems for handling long event messages in a distributed computing environment, particularly where such messages exceed the size limits of standard syslog protocols. The problem addressed is the inability of traditional syslog systems to transmit large event messages in a single transmission, leading to message truncation or loss. The solution involves a method for unpackaging and forwarding portions of long event messages from component syslog messages to higher-level application functionality. The method involves a second entity, such as a log collector or aggregator, receiving a component syslog message that contains a portion of a longer event message. The second entity stores this portion for subsequent forwarding to higher-level application functionality, ensuring the complete event message is reconstructed and processed. This approach allows the system to handle messages larger than the standard syslog payload limit by breaking them into smaller, manageable components while preserving the integrity of the original event data. The method ensures that fragmented event messages are reassembled correctly at the application level, enabling comprehensive event logging and analysis. This solution is particularly useful in environments where detailed event data is critical for monitoring, debugging, or compliance purposes.
20. Computer instructions encoded in a physical data-storage device that, when executed by one or more processors of a distributed computer system having one or more processors, one or more memories, and a syslog-messaging subsystem, control the distribution computer system to: generate, by application-level functionality within distributed-computer-system components, a long event message that, were the long event message packaged in a single syslog message, would form a syslog message with a length that exceeds a specified syslog supported message length, package, by the application-level functionality within the distributed-computer-system components, the long event message into two or more component syslog messages, transmit the component syslog messages from the application-level functionality within distributed-computer-system components to an administration computer system through the syslog-messaging subsystem, receive the component syslog messages by application-level functionality within the administration computer system, and generate the long event message from the received component syslog messages by the application-level functionality within the administration computer system.
This invention relates to distributed computer systems and addresses the challenge of transmitting long event messages that exceed the maximum supported length of syslog messages. Syslog is a standard protocol for message logging, but it has a fixed message length limit, which can prevent the transmission of detailed or complex event data. The invention provides a solution by breaking down long event messages into smaller component syslog messages that comply with the length restrictions. Application-level functionality within the distributed computer system generates a long event message that would exceed the syslog-supported length if sent as a single message. The system then packages this long message into two or more component syslog messages, each within the allowed length. These component messages are transmitted to an administration computer system via the syslog-messaging subsystem. The administration system receives the component messages and reassembles them into the original long event message using application-level functionality. This approach ensures that detailed event data can be transmitted and reconstructed without violating syslog length constraints, improving system monitoring and troubleshooting capabilities. The invention leverages existing syslog infrastructure while extending its functionality to handle larger messages.
Unknown
January 14, 2020
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.