Google Chronicle (om_chronicle)
Google Chronicle is a cloud service built as a specialized layer on top of the core Google infrastructure. It is designed for enterprises to privately retain, analyze, and search the massive amounts of security and network telemetry they generate. Chronicle normalizes, indexes, correlates, and analyzes the data to provide instant analysis and context on risky activity.
The Chronicle Ingestion API enables you to forward logs directly to Chronicle. This module supports forwarding logs to the udmevents and unstructuredlogentries endpoints. Event data is sent in batches, thus reducing HTTP response latency and improving data throughput.
om_chronicle can send logs to Chronicle Ingestion API v1 and v2. API v1 requires a Chronicle Ingestion API access key. Although this method is deprecated, it still works when writing this documentation. API v2 requires a Google Developer Service Account for OAuth 2.0 authentication.
To examine the supported platforms, see the list of installation packages. |
Output log format
Unstructured logs
om_chronicle forwards unstructured log records over HTTP(S) as JSON payload in the following format:
{
"log_type": "<log_type>",
"customer_id": "<customer_id>",
"entries": [
{
"log_text": "<json_escaped_raw_event>",
"ts_rfc3339": "<event_time>"
}
]
}
For example:
{
"log_type": "BIND_DNS",
"customer_id": "c8c65bfa-5f2c-42d4-9189-64bb7b939f2c",
"entries": [
{
"log_text": "<13>Oct 9 17:33:15 SERVER-1 09-Oct-2023 17:33:15.187 queries: info: client 10.120.20.20#4238: query: example.com IN A + (100.90.80.102)",
"ts_rfc3339": "2023-10-09T17:51:27.122616+02:00"
}
]
}
Required fields:
-
log_type
is the value specified by the LogType directive. -
log_text
is the JSON escaped value of the$raw_event
field.
Optional fields:
-
customer_id
is present if the API v1 CustomerId or API v2 CustomerIddirective is specified. -
ts_rfc3339
is present if the$EventReceivedTime
core field is present. If this field is not required, use the delete() procedure to remove$EventReceivedTime
. This can be useful if the log text already contains a received date and time.
Additional metadata, including the NXLog Agent-specific fields $SourceModuleName
and $SourceModuleType
, will not be included in the output unless these values have been written to the $raw_event
field.
The processing required to achieve this depends on the format of the input data.
For example, if the input data is in JSON format, you need to:
-
Use parse_json() to parse
$raw_event
into fields. -
Create and populate any additional custom fields.
-
Use to_json() to convert the fields to JSON format and update the value of
$raw_event
.
Structured logs
om_chronicle forwards structured log records over HTTP(S) as JSON payload in the following format:
{
"metadata": {
"event_type": "NETWORK_CONNECTION",
"event_timestamp": "<event_time>",
"description": "<json_escaped_raw_event>",
"ingestion_labels": [
{
"key": "source_module_name",
"value": "<source_module_name>"
},
{
"key": "source_module_type",
"value": "<source_module_type>"
}
]
},
"network": {
"ip_protocol": "TCP"
},
"principal": {
"ip": "<message_source_address>"
},
"target": {
"application": "nxlog",
"ip": "127.0.0.1"
}
}
For example:
{
"metadata": {
"description": "16-May-2023 20:11:15.187 client 10.120.20.20#4238: query: example.com IN A + (100.90.80.102)",
"event_timestamp": "2023-05-16T20:11:27.421707+05:45",
"event_type": "NETWORK_CONNECTION",
"ingestion_labels": [
{
"key": "source_module_name",
"value": "tcp"
},
{
"key": "source_module_type",
"value": "im_tcp"
}
]
},
"network": {
"ip_protocol": "TCP"
},
"principal": {
"ip": "127.0.0.1"
},
"target": {
"application": "nxlog",
"ip": "127.0.0.1"
}
}
Required fields:
-
description
is the JSON escaped value of the$raw_event
field. -
event_timestamp
is the value of$EventReceivedTime
. -
ingestion_labels.source_module_name
is the value of$SourceModuleName
, i.e., the name of the NXLog Agent input module instance. -
ingestion_labels.source_module_type
is the value of$SourceModuleType
, i.e., the NXLog Agent input module.
If you remove any of these fields from the log record, for example, with the delete() procedure, the field value will be set to an empty string.
Configuration
Log data sent to the destination with this module must be UTF-8 encoded, otherwise, the target will refuse and drop the events. If the source does not guarantee that events are UTF-8 encoded, use the xm_charconv extension module to convert the log data to UTF-8:
|
The om_chronicle module accepts the following directives in addition to the common module directives.
The module can use Chronicle Ingestion API v1 or API v2 and works in either unstructured or structured mode.
Chronicle Ingestion API v1 directives
Specifies the Google Chronicle Ingestion API version. The supported values for API v1 are |
|
This directive specifies a Chronicle Ingestion API access key required for API v1. Chronicle responds with HTTP error 403 if this key is not valid. |
|
This directive specifies the unique identifier (UUID) corresponding to your Chronicle instance. The ID is provided by your Chronicle representative. The Ingestion API responds with HTTP error 400 or 403 if the UUID is not valid. This directive is optional for API v1. |
Chronicle Ingestion API v2 directives
Specifies the Google Chronicle Ingestion API version. The supported values for API v2 are |
|
This directive specifies the path to the private key file of the Google Developer Service Account required for authenticating with Google Chronicle Ingestion API v2. Chronicle responds with HTTP error 403 if this key is not valid. See Configuring a Google Cloud service account for more information. |
|
This directive specifies the unique identifier (UUID) corresponding to your Chronicle instance. The ID is provided by your Chronicle representative. The Ingestion API responds with HTTP error 400 or 403 if the UUID is not valid. This directive is required for API v2. |
Unstructured output format directives
The following directives define how the module formats the log records it sends to Google Chronicle in unstructured mode.
This directive specifies the Google Chronicle API endpoint.
The accepted value for unstructured mode is This mode supports forwarding unstructured logs to the unstructuredlogentries endpoint. Log data normalization is then handled by Google Chronicle. |
|
Must correspond to a valid log type. To retrieve the list of possible log types, visit https://malachiteingestion-pa.googleapis.com/v1/logtypes?key=YOUR_API_KEY. This directive is required in unstructured mode. |
Structured output format directives
The following directives define how the module formats the log records it sends to Google Chronicle in structured mode.
This directive specifies the Google Chronicle API endpoint.
The accepted value for structured mode is This mode supports forwarding logs to the udmevents endpoint. Log data must be in the UDM format supported by Google Chronicle. |
|
The output data from each NXLog Agent module is mapped to the Chronicle UDM format using a custom schema mapping. Use this directive to specify the name of a different schema file and override the default mapping. |
|
Use this directive to map the data schema dynamically.
|
|
Specify the path to the directory containing the custom schema files defined by the ChronicleSchema and SchemaMap directives. The path can be relative to the configuration directory. |
HTTP(S) directives
The following directives are for configuring HTTP(S) connection settings.
This optional directive specifies the recommended size (in bytes) of each batch of log data. The maximum size for unstructured logs is 1 MB (1,048,576 bytes). |
|
This optional directive can be specified multiple times to add custom headers to each HTTP request. |
|
This optional directive can be used to enable HTTP compression for outgoing HTTP messages.
The possible values are |
|
HTTP basic authorization username. You must also set the HTTPBasicAuthPassword directive to use HTTP authorization. |
|
HTTP basic authorization password. You must also set the HTTPBasicAuthUser directive to use HTTP authorization. |
|
This boolean directive specifies whether the connection should be allowed with an expired certificate.
If set to |
|
This boolean directive specifies that the connection should be allowed without certificate verification.
If set to |
|
This directive specifies a path to a directory containing certificate authority (CA) certificates. These certificates will be used to verify the certificate presented by the remote host. The certificate files must be named using the OpenSSL hashed format, i.e. the hash of the certificate followed by .0, .1 etc. To find the hash of a certificate using OpenSSL:
For example, if the certificate hash is A remote host’s self-signed certificate (which is not signed by a CA) can also be trusted by including a copy of the certificate in this directory. NXLog Agent uses the operating system root certificate store if this directive is not specified.
Unix-like operating systems commonly store root certificates in |
|
This specifies the path of the certificate authority (CA) certificate that will be used to verify the certificate presented by the remote host. A remote host’s self-signed certificate (which is not signed by a CA) can be trusted by specifying the remote host certificate itself. In the case of certificates signed by an intermediate CA, the certificate specified must contain the complete certificate chain (certificate bundle). |
|
This specifies the path of the certificate file that will be presented to the remote host during the HTTPS handshake. |
|
This specifies the path of the private key file that was used to generate the certificate specified by the HTTPSCertFile directive. This is used for the HTTPS handshake. |
|
This optional directive is used to specify the protocol, IP address (or hostname) and port number of the HTTP or SOCKS proxy server to be used.
The format is |
|
This optional directive sets the reconnect interval in seconds. If it is set, the module attempts to reconnect in every defined second. If it is not set, the reconnect interval will start at 1 second and doubles on every attempt. If the duration of the successful connection is greater than the current reconnect interval, then the reconnect interval will be reset to 1 sec. |
Optional directives
This directive specifies a regional endpoint. Supported values are: |
|||||
Optional directive for specifying the Chronicle Ingestion API endpoint. Alternatively, use the optional ChronicleRegion, API v1 ChronicleVersion or API v2 ChronicleVersion, unstructured ChronicleMode, structured ChronicleMode, and ChronicleKey directives to use the default endpoint:
Depending on the URL provided, the module operates in plain HTTP or HTTPS mode. If you do not specify the port number in the URL, it uses port 80 for HTTP and port 443 for HTTPS.
|
Examples
This configuration collects logs from a BIND 9 DNS server and forwards them to Chronicle.
Since the BIND_DNS
LogType requires the events to be in syslog format, log records are converted to syslog using the to_syslog_bsd() procedure of the xm_syslog module.
# Google Chronicle API key, required.
define API_KEY <YOUR_API_KEY>
<Extension syslog>
Module xm_syslog
</Extension>
<Output chronicle>
Module om_chronicle
ChronicleKey %API_KEY%
# Unstructured events
ChronicleMode unstructured
# Identifies the type of logs in the batch.
LogType BIND_DNS
<Exec>
$Message = $raw_event;
to_syslog_bsd();
</Exec>
</Output>
09-Oct-2023 17:33:15.187 queries: info: client 10.120.20.20#4238: query: example.com IN A + (100.90.80.102)
09-Oct-2023 17:34:16.120 queries: info: client 10.120.20.20#4238: query: example.com IN A + (100.90.80.102)
09-Oct-2023 17:35:17.165 queries: info: client 10.120.20.20#4238: query: example.com IN A + (100.90.80.102)
The following is the JSON-formatted log record that will be sent to Google Chronicle.
Note that the ts_rfc3339
field is added by the module and specifies the time when the event was received and corresponds to the $EventReceivedTime core field.
{
"log_type": "BIND_DNS",
"entries": [
{
"log_text": "<13>Oct 9 17:33:15 SERVER-1 09-Oct-2023 17:33:15.187 queries: info: client 10.120.20.20#4238: query: example.com IN A + (100.90.80.102)",
"ts_rfc3339": "2023-10-09T17:51:27.122616+02:00"
},
{
"log_text": "<13>Oct 9 17:34:16 SERVER-1 09-Oct-2023 17:34:16.120 queries: info: client 10.120.20.20#4238: query: example.com IN A + (100.90.80.102)",
"ts_rfc3339": "2023-10-09T17:51:27.126157+02:00"
},
{
"log_text": "<13>Oct 9 17:35:17 SERVER-1 09-Oct-2023 17:35:17.165 queries: info: client 10.120.20.20#4238: query: example.com IN A + (100.90.80.102)",
"ts_rfc3339": "2023-10-09T17:51:27.126176+02:00"
}
]
}
This configuration collects logs from a BIND 9 DNS server and forwards them to Chronicle in UDM format. It parses log records into structured data with a regular expression and uses a custom ChronicleSchema file in the same folder as the NXLog Agent configuration.
# Google Chronicle API key, required.
define API_KEY <YOUR_API_KEY>
<Input dns>
Module im_file
File '/var/log/bind.log'
<Exec>
if $raw_event =~ /(?x)^(?<EventTime>\S+\s\S+)\s(?<category>.*):\s
(?<severity>.*):\s.*\s(?<source>.*)\#
(?<port>\d+):\s+(?<message>.+)$/
{
$EventTime = parsedate($EventTime);
}
</Exec>
</Input>
<Output chronicle_udm>
Module om_chronicle
ChronicleKey %API_KEY%
ChronicleMode structured
ChronicleSchema 'bind_dns.json'
</Output>
{
"metadata": {
"event_type": "NETWORK_DNS",
"event_timestamp": "$EventTime",
"ingested_timestamp": "$EventReceivedTime",
"description": "$message",
"product_name": "BIND 9",
"vendor_name": "ISC",
"product_event_type": "$category",
"severity_details": "$severity",
"ingestion_labels": [
{
"key": "source_module_name",
"value": "$SourceModuleName"
},
{
"key": "source_module_type",
"value": "$SourceModuleType"
}
]
},
"src": {
"ip": "$source",
"port": "$port"
},
"principal": {
"hostname": "$Hostname"
}
}
09-Oct-2023 17:33:15.187 queries: info: client 10.120.20.20#4238: query: example.com IN A + (100.90.80.102)
The following is the JSON-formatted log record that will be sent to Google Chronicle.
{
"events": [
{
"metadata": {
"description": "query: example.com IN A + (100.90.80.102)",
"event_timestamp": "2023-10-09T17:35:17.165000+02:00",
"event_type": "NETWORK_DNS",
"ingested_timestamp": "2023-10-09T17:39:17.901029+02:00",
"ingestion_labels": [
{
"key": "source_module_name",
"value": "dns"
},
{
"key": "source_module_type",
"value": "im_file"
}
],
"product_event_type": "queries",
"product_name": "BIND 9",
"severity_details": "info",
"vendor_name": "ISC"
},
"principal": {
"hostname": "SERVER-1"
},
"src": {
"ip": "10.120.20.20",
"port": "4238"
}
}
]
}
This configuration sends logs to Chronicle in UDM format.
The output instance implements schema-selection logic based on the $EventType
field.
It sets the SchemaDir to a folder relative to the NXLog Agent configuration file and uses the SchemaMap directive and set_schema() procedure to set the UDM schema dynamically.
# Google Chronicle API key, required.
define API_KEY <YOUR_API_KEY>
<Output chronicle_udm>
Module om_chronicle
ChronicleKey %API_KEY%
ChronicleMode structured
SchemaDir 'chronicle-schemas'
<SchemaMap>
copy file-copy.json
delete file-delete.json
spawn process-create.json
default default.json
</SchemaMap>
<Exec>
if ($EventType == "File copied") {
set_schema("copy");
}
else if ($EventType == "File deleted") {
set_schema("delete");
}
else if ($EventType == "Process created") {
set_schema("spawn");
}
else {
set_schema("default");
}
</Exec>
</Output>
This configuration collects logs from a BIND 9 DNS server and forwards them to Chronicle in unstructured format. Sending logs to Chronicle Ingestion API v2 requires the following directives:
# Chronicle UUID, required.
define CUSTOMER_ID <YOUR_CHRONICLE_UUID>
<Extension syslog>
Module xm_syslog
</Extension>
<Output chronicle_v2>
Module om_chronicle
ChronicleVersion v2
CustomerId %CUSTOMER_ID%
# Google Service Account credentias file, required.
CredentialsFile '/opt/nxlog/etc/credentials.json'
# Unstructured events
ChronicleMode unstructured
# Identifies the type of logs in the batch.
LogType BIND_DNS
<Exec>
$Message = $raw_event;
to_syslog_bsd();
</Exec>
</Output>