Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Send logs to Azure Data Explorer (Kusto)
The Kusto output plugin allows to ingest your logs into an Azure Data Explorer cluster, via the Queued Ingestion mechanism.
You can create an Azure Data Explorer cluster in one of the following ways:
Fluent-Bit will use the application's credentials, to ingest data into your cluster.
Fluent-Bit ingests the event data into Kusto in a JSON format, that by default will include 3 properties:
log - the actual event payload.
tag - the event tag.
timestamp - the event timestamp.
A table with the expected schema must exist in order for data to be ingested properly.
By default, Kusto will insert incoming ingestions into a table by inferring the mapped table columns, from the payload properties. However, this mapping can be customized by creatng a JSON ingestion mapping. The plugin can be configured to use an ingestion mapping via the ingestion_mapping_reference configuration key.
Get started quickly with this configuration file:
If you get a 403 Forbidden error response, make sure that:
You provided the correct AAD registered application credentials.
You authorized the application to ingest into your database or table.
Send logs to Amazon Kinesis Streams
The Amazon Kinesis Data Streams output plugin allows to ingest your records into the Kinesis service.
This is the documentation for the core Fluent Bit Kinesis plugin written in C. It has all the core features of the aws/amazon-kinesis-streams-for-fluent-bit Golang Fluent Bit plugin released in 2019. The Golang plugin was named kinesis; this new high performance and highly efficient kinesis plugin is called kinesis_streams to prevent conflicts/confusion.
Currently, this kinesis_streams plugin will always use a random partition key when uploading records to kinesis via the PutRecords API.
See here for details on how AWS credentials are fetched.
In order to send records into Amazon Kinesis Data Streams, you can run the plugin from the command line or through the configuration file:
The kinesis_streams plugin, can read the parameters from the command line through the -p argument (property), e.g:
In your main configuration file append the following Output section:
The following AWS IAM permissions are required to use this plugin:
Fluent Bit 1.7 adds a new feature called workers which enables outputs to have dedicated threads. This kinesis_streams plugin fully supports workers.
Example:
If you enable a single worker, you are enabling a dedicated thread for your Kinesis output. We recommend starting with without workers, evaluating the performance, and then adding workers one at a time until you reach your desired/needed throughput. For most users, no workers or a single worker will be sufficient.
Amazon distributes a container image with Fluent Bit and these plugins.
github.com/aws/aws-for-fluent-bit
Our images are available in Amazon ECR Public Gallery. You can download images with different tags by following command:
For example, you can pull the image with latest version by:
If you see errors for image pull limits, try log into public ECR with your AWS credentials:
You can check the Amazon ECR Public official doc for more details.
You can use our SSM Public Parameters to find the Amazon ECR image URI in your region:
For more see the AWS for Fluent Bit github repo.
Official and Microsoft Certified Azure Storage Blob connector
The Azure Blob output plugin allows ingesting your records into Azure Blob Storage service. This connector is designed to use the Append Blob and Block Blob API.
Our plugin works with the official Azure Service and also can be configured to be used with a service emulator such as Azurite.
Before getting started, make sure you already have an Azure Storage account. As a reference, the following link explains step-by-step how to set up your account:
We expose different configuration properties. The following table lists all the options available, and the next section has specific configuration details for the official service or the emulator.
| Key | Description | default |
|---|---|---|
As mentioned above, you can either deliver records to the official service or an emulator. Below we have an example for each use case.
The following configuration example generates a random message with a custom tag:
After you run the configuration file above, you will be able to query the data using the Azure Storage Explorer. The example above will generate the following content in the explorer:
The quickest way to get started is to install Azurite using npm:
then run the service:
Azurite comes with a default account_name and shared_key, so make sure to use the specific values provided in the example below (do an exact copy/paste):
after running that Fluent Bit configuration you will see the data flowing into Azurite:
Send logs and metrics to Amazon CloudWatch
The Amazon CloudWatch output plugin allows to ingest your records into the CloudWatch Logs service. Support for CloudWatch Metrics is also provided via EMF.
This is the documentation for the core Fluent Bit CloudWatch plugin written in C. It can replace the aws/amazon-cloudwatch-logs-for-fluent-bit Golang Fluent Bit plugin released last year. The Golang plugin was named cloudwatch; this new high performance CloudWatch plugin is called cloudwatch_logs to prevent conflicts/confusion. Check the amazon repo for the Golang plugin for details on the deprecation/migration plan for the original plugin.
See here for details on how AWS credentials are fetched.
In order to send records into Amazon Cloudwatch, you can run the plugin from the command line or through the configuration file:
The cloudwatch plugin, can read the parameters from the command line through the -p argument (property), e.g:
In your main configuration file append the following Output section:
The following AWS IAM permissions are required to use this plugin:
Fluent Bit 1.7 adds a new feature called workers which enables outputs to have dedicated threads. This cloudwatch_logs plugin has partial support for workers. The plugin can support a single worker; enabling multiple workers will lead to errors/indeterminate behavior.
Example:
If you enable a single worker, you are enabling a dedicated thread for your CloudWatch output. We recommend starting without workers, evaluating the performance, and then enabling a worker if needed. For most users, the plugin can provide sufficient throughput without workers.
Sometimes, you may want the log group or stream name to be based on the contents of the log record itself. This plugin supports templating log group and stream names using Fluent Bit record_accessor syntax.
Here is an example usage, for a common use case- templating log group and stream names based on Kubernetes metadata.
Recall that the kubernetes filter can add metadata which will look like the following:
Using record_accessor, we can build a template based on this object.
Here is our output configuration:
With the above kubernetes metadata, the log group name will be application-logs-ip-10-1-128-166.us-east-2.compute.internal.my-namespace. And the log stream name will be myapp-5468c5d4d7-n2swr.myapp.
If the kubernetes structure is not found in the log record, then the log_group_name and log_stream_prefix will be used instead, and Fluent Bit will log an error like:
Notice in the example above, that the template values are separated by dot characters. This is important; the Fluent Bit record_accessor library has a limitation in the characters that can separate template variables- only dots and commas (. and ,) can come after a template variable. This is because the templating library must parse the template and determine the end of a variable.
Assume that your log records contain the metadata keys container_name and task. The following would be invalid templates because the two template variables are not separated by commas or dots:
$task-$container_name
$task/$container_name
$task_$container_name
$taskfooo$container_name
However, the following are valid:
$task.$container_name
$task.resource.$container_name
$task.fooo.$container_name
And the following are valid since they only contain one template variable with nothing after it:
fooo$task
fooo____$task
fooo/bar$container_name
Fluent Bit has different input plugins (cpu, mem, disk, netif) to collect host resource usage metrics. cloudwatch_logs output plugin can be used to send these host metrics to CloudWatch in Embedded Metric Format (EMF). If data comes from any of the above mentioned input plugins, cloudwatch_logs output plugin will convert them to EMF format and sent to CloudWatch as JSON log. Additionally, if we set json/emf as the value of log_format config option, CloudWatch will extract custom metrics from embedded JSON payload.
Note: Right now, only cpu and mem metrics can be sent to CloudWatch.
For using the mem input plugin and sending memory usage metrics to CloudWatch, we can consider the following example config file. Here, we use the aws filter which adds ec2_instance_id and az (availability zone) to the log records. Later, in the output config section, we set ec2_instance_id as our metric dimension.
The following config will set two dimensions to all of our metrics- ec2_instance_id and az.
Amazon distributes a container image with Fluent Bit and these plugins.
github.com/aws/aws-for-fluent-bit
Our images are available in Amazon ECR Public Gallery. You can download images with different tags by following command:
For example, you can pull the image with latest version by:
If you see errors for image pull limits, try log into public ECR with your AWS credentials:
You can check the Amazon ECR Public official doc for more details
You can use our SSM Public Parameters to find the Amazon ECR image URI in your region:
For more see the AWS for Fluent Bit github repo.
Send logs, metrics to Azure Log Analytics
Azure output plugin allows to ingest your records into service.
To get more details about how to setup Azure Log Analytics, please refer to the following documentation:
In order to insert records into an Azure Log Analytics instance, you can run the plugin from the command line or through the configuration file:
The azure plugin, can read the parameters from the command line in two ways, through the -p argument (property), e.g:
In your main configuration file append the following Input & Output sections:
Send logs to Amazon Kinesis Firehose
The Amazon Kinesis Data Firehose output plugin allows to ingest your records into the service.
This is the documentation for the core Fluent Bit Firehose plugin written in C. It can replace the Golang Fluent Bit plugin released last year. The Golang plugin was named firehose; this new high performance and highly efficient firehose plugin is called kinesis_firehose to prevent conflicts/confusion.
See for details on how AWS credentials are fetched.
In order to send records into Amazon Kinesis Data Firehose, you can run the plugin from the command line or through the configuration file:
The firehose plugin, can read the parameters from the command line through the -p argument (property), e.g:
In your main configuration file append the following Output section:
The following AWS IAM permissions are required to use this plugin:
Fluent Bit 1.7 adds a new feature called workers which enables outputs to have dedicated threads. This kinesis_firehose plugin fully supports workers.
Example:
If you enable a single worker, you are enabling a dedicated thread for your Firehose output. We recommend starting with without workers, evaluating the performance, and then adding workers one at a time until you reach your desired/needed throughput. For most users, no workers or a single worker will be sufficient.
Amazon distributes a container image with Fluent Bit and these plugins.
Our images are available in Amazon ECR Public Gallery. You can download images with different tags by following command:
For example, you can pull the image with latest version by:
If you see errors for image pull limits, try log into public ECR with your AWS credentials:
You can use our SSM Public Parameters to find the Amazon ECR image URI in your region:
Forward is the protocol used by to route messages between peers. The forward output plugin provides interoperability between and . There are no configuration steps required besides specifying where is located, which can be a local or a remote destination.
This plugin offers two different transports and modes:
Forward (TCP): It uses a plain TCP connection.
Secure Forward (TLS): when TLS is enabled, the plugin switch to Secure Forward mode.
The following parameters are mandatory for either Forward for Secure Forward modes:
| Key | Description | Default |
|---|
That configuration file specifies that it will listen for TCP connections on the port 24224 through the forward input type. Then for every message with a fluent_bit TAG, will print the message to the standard output.
DISCLAIMER: the following example does not consider the generation of certificates for best practice on production environments.
Paste this content in a file called flb.conf:
Paste this content in a file called fld.conf:
If you're using Fluentd v1, set up it as below:
Start Fluentd:
Start Fluent Bit:
After five seconds, Fluent Bit will write records to Fluentd. In Fluentd output you will see a message like this:
GELF is Extended Log Format. The GELF output plugin allows to send logs in GELF format directly to a Graylog input using TLS, TCP or UDP protocols.
The following instructions assumes that you have a fully operational Graylog server running in your environment.
According to , there are some mandatory and optional fields which are used by Graylog in GELF format. These fields are determined with Gelf\*_Key_ key in this plugin.
| Key | Description | default |
|---|
GELF output plugin supports TLS/SSL, for more details about the properties available and general configuration, please refer to the section.
If you're using Fluent Bit to collect Docker logs, note that Docker places your log in JSON under key log. So you can set log as your Gelf_Short_Message_Key to send everything in Docker logs to Graylog. In this case, you need your log value to be a string; so don't parse it using JSON parser.
The order of looking up the timestamp in this plugin is as follows:
Value of Gelf_Timestamp_Key provided in configuration
Value of timestamp key
Timestamp does not set by Fluent Bit. In this case, your Graylog server will set it to the current timestamp (now).
The version of GELF message is also mandatory and Fluent Bit sets it to 1.1 which is the current latest version of GELF.
If you use udp as transport protocol and set Compress to true, Fluent Bit compresses your packets in GZIP format, which is the default compression that Graylog offers. This can be used to trade more CPU load for saving network bandwidth.
If you're using Fluent Bit for shipping Kubernetes logs, you can use something like this as your configuration file:
By default, GELF tcp uses port 12201 and Docker places your logs in /var/log/containers directory. The logs are placed in value of the log key. For example, this is a log saved by Docker:
Now, this is what happens to this log:
Fluent Bit GELF plugin adds "version": "1.1" to it.
We used this data key as Gelf_Short_Message_Key; so GELF plugin changes it to short_message.
Timestamp is generated.
Finally, this is what our Graylog server input sees:
FlowCounter is the protocol to count records. The flowcounter output plugin allows to count up records and its size.
The plugin supports the following configuration parameters:
| Key | Description | Default |
|---|
You can run the plugin from the command line or through the configuration file:
From the command line you can let Fluent Bit count up a data with the following options:
In your main configuration file append the following Input & Output sections:
Once Fluent Bit is running, you will see the reports in the output interface similar to this:
BigQuery output plugin is an experimental plugin that allows you to stream records into service. The implementation does not support the following, which would be expected in a full production version:
.
using insertId.
using templateSuffix.
Fluent Bit streams data into an existing BigQuery table using a service account that you specify. Therefore, before using the BigQuery output plugin, you must create a service account, create a BigQuery dataset and table, authorize the service account to write to the table, and provide the service account credentials to Fluent Bit.
To stream data into BigQuery, the first step is to create a Google Cloud service account for Fluent Bit:
Fluent Bit does not create datasets or tables for your data, so you must create these ahead of time. You must also grant the service account WRITER permission on the dataset:
Within the dataset you will need to create a table for the data to reside in. You can follow the following instructions for creating your table. Pay close attention to the schema. It must match the schema of your output JSON. Unfortunately, since BigQuery does not allow dots in field names, you will need to use a filter to change the fields for many of the standard inputs (e.g, mem or cpu).
Fluent Bit BigQuery output plugin uses a JSON credentials file for authentication credentials. Download the credentials file by following these instructions:
Using identity federation, you can grant on-premises or multi-cloud workloads access to Google Cloud resources, without using a service account key. It can be used as a more secure alternative to service account credentials. Google Cloud's workload identity federation supports several identity providers (see documentation) but Fluent Bit BigQuery plugin currently supports Amazon Web Services (AWS) only.
You must configure workload identity federation in GCP before using it with Fluent Bit.
If you are using a Google Cloud Credentials File, the following configuration is enough to get you started:
The http output plugin allows to flush your records into a HTTP endpoint. For now the functionality is pretty basic and it issues a POST request with the data records in (or JSON) format.
| Key | Description | default |
|---|
In order to insert records into a HTTP server, you can run the plugin from the command line or through the configuration file:
The http plugin, can read the parameters from the command line in two ways, through the -p argument (property) or setting them directly through the service URI. The URI format is the following:
Using the format specified, you could start Fluent Bit through:
In your main configuration file, append the following Input & Output sections:
By default, the URI becomes tag of the message, the original tag is ignored. To retain the tag, multiple configuration sections have to be made based and flush to different URIs.
Another approach we also support is the sending the original message tag in a configurable header. It's up to the receiver to do what it wants with that header field: parse it and use it as the tag for example.
To configure this behaviour, add this config:
Provided you are using Fluentd as data receiver, you can combine in_http and out_rewrite_tag_filter to make use of this HTTP header.
Notice how we override the tag, which is from URI path, with our custom header
Suggested configuration for Sumo Logic using json_lines with iso8601 timestamps. The PrivateKey is specific to a configured HTTP collector.
Counter is a very simple plugin that counts how many records it's getting upon flush time. Plugin output is as follows:
You can run the plugin from the command line or through the configuration file:
From the command line you can let Fluent Bit count up a data with the following options:
In your main configuration file append the following Input & Output sections:
Once Fluent Bit is running, you will see the reports in the output interface similar to this:
The file output plugin allows to write the data received through the input plugin to file.
The plugin supports the following configuration parameters:
| Key | Description | Default |
|---|
Output time, tag and json records. There is no configuration parameters for out_file.
Output the records as JSON (without additional tag and timestamp attributes). There is no configuration parameters for plain format.
Output the records as csv. Csv supports an additional configuration parameter.
Output the records as LTSV. LTSV supports an additional configuration parameter.
Output the records using a custom format template.
This accepts a formatting template and fills placeholders using corresponding values in a record.
For example, if you set up the configuration as below:
You will get the following output:
You can run the plugin from the command line or through the configuration file:
From the command line you can let Fluent Bit count up a data with the following options:
In your main configuration file append the following Input & Output sections:
Send logs, data, metrics to Amazon S3
The Amazon S3 output plugin allows you to ingest your records into the cloud object store.
The plugin can upload data to S3 using the or using S3 . Multipart is the default and is recommended; Fluent Bit will stream data in a series of 'parts'. This limits the amount of data it has to buffer on disk at any point in time. By default, every time 5 MiB of data have been received, a new 'part' will be uploaded. The plugin can create files up to gigabytes in size from many small chunks/parts using the multipart API. All aspects of the upload process are configurable using the configuration options.
The plugin allows you to specify a maximum file size, and a timeout for uploads. A file will be created in S3 when the max size is reached, or the timeout is reached- whichever comes first.
Records are stored in files in S3 as newline delimited JSON.
The plugin requires the following AWS IAM permissions:
The s3 output plugin is special because its use case is to upload files of non-trivial size to an Amazon S3 bucket. This is in contrast to most other outputs which send many requests to upload data in batches of a few Megabytes or less.
When Fluent Bit recieves logs, it stores them in chunks, either in memory or the filesystem depending on your settings. A chunk is usually around 2 MB in size. Fluent Bit sends the chunks in order to each output that matches their tag. Most outputs then send the chunk immediately to their destination. A chunk is sent to the output's "flush callback function", which must return one of FLB_OK, FLB_RETRY, or FLB_ERROR. Fluent Bit keeps count of the return values from each outputs "flush callback function"; these counters are the data source for Fluent Bit's error, retry, and success metrics available in prometheus format via its monitoring interface.
The S3 output plugin is a Fluent Bit output plugin and thus it conforms to the Fluent Bit output plugin specification. However, since the S3 use case is to upload large files, generally much larger than 2 MB, its behavior is different. The S3 "flush callback function" simply buffers the incoming chunk to the filesystem, and returns an FLB_OK. Consequently, the prometheus metrics available via the Fluent Bit http server are meaningless for S3. In addition, the storage.total_limit_size parameter is not meaningful for S3 since it has its own buffering system in the store_dir. Instead, use store_dir_limit_size.
S3 uploads are primarily initiated via the S3 "timer callback function", which runs separately from its "flush callback function". Because S3 has its own system of buffering and its own callback to upload data, the normal sequential data ordering of chunks provided by the Fluent Bit engine may be compromised. Consequently, S3 has the presevere_data_ordering option which will ensure data is uploaded in the original order it was collected by Fluent Bit.
You must use store_dir_limit_size to limit the space on disk used by S3 buffer files.
The original ordering of data inputted to Fluent Bit may not be preserved unless you enable preserve_data_ordering On.
In Fluent Bit, all logs have an associated tag. The s3_key_format option lets you inject the tag into the s3 key using the following syntax:
$TAG => the full tag
$TAG[n] => the nth part of the tag (index starting at zero). This syntax is copied from the rewrite tag filter. By default, “parts” of the tag are separated with dots, but you can change this with s3_key_format_tag_delimiters.
In the example below, assume the date is January 1st, 2020 00:00:00 and the tag associated with the logs in question is my_app_name-logs.prod.
With the delimiters as . and -, the tag will be split into parts as follows:
$TAG[0] = my_app_name
$TAG[1] = logs
$TAG[2] = prod
So the key in S3 will be /prod/my_app_name/2020/01/01/00/00/00/bgdHN1NM.gz.
The Fluent Bit S3 output was designed to ensure that previous uploads will never be over-written by a subsequent upload. Consequently, the s3_key_format supports time formatters, $UUID, and $INDEX. $INDEX is special because it is saved in the store_dir; if you restart Fluent Bit with the same disk, then it can continue incrementing the index from its last value in the previous run.
For files uploaded with the PutObject API, the S3 output requires that a unique random string be present in the S3 key. This is because many of the use cases for PutObject uploads involve a short time period between uploads such that a timestamp in the S3 key may not be unique enough between uploads. For example, if you only specify minute granularity timestamps in the S3 key, with a small upload size, it is possible to have two uploads that have timestamps set in the same minute. This "requirement" can be disabled with static_file_path On.
There are three cases where the PutObject API is used:
When you explicitly set use_put_object On
On startup when the S3 output finds old buffer files in the store_dir from a previous run and attempts to send all of them at once.
On shutdown, when to prevent data loss the S3 output attempts to send all currently buffered data at once.
Consequently, you should always specify $UUID somewhere in your S3 key format. Otherwise, if the PutObject API is used, S3 will append a random 8 character UUID to the end of your S3 key. This means that a file extension set at the end of an S3 key will have the random UUID appended to it. This behavior can be disabled with static_file_path On.
Let's walk through this via an example. First case, we attempt to set a .gz extension without specifying $UUID.
In the case where pending data is uploaded on shutdown, if the tag was app, the S3 key in the S3 bucket might be:
The S3 output appended a random string to the "extension", since this upload on shutdown used the PutObject API.
There are two ways of disabling this behavior. Option 1, use static_file_path:
Option 2, explicitly define where the random UUID will go in the S3 key format:
The store_dir is used to temporarily store data before it is uploaded. If Fluent Bit is stopped suddenly it will try to send all data and complete all uploads before it shuts down. If it can not send some data, on restart it will look in the store_dir for existing data and will try to send it.
Multipart uploads are ideal for most use cases because they allow the plugin to upload data in small chunks over time. For example, 1 GB file can be created from 200 5MB chunks. While the file size in S3 will be 1 GB, only 5 MB will be buffered on disk at any one point in time.
In these situations, we recommend using the PutObject API, and sending data frequently, to avoid local buffering as much as possible. This will limit data loss in the event Fluent Bit is killed unexpectedly.
The following settings are recommended for this use case:
Fluent Bit 1.7 adds a new feature called workers which enables outputs to have dedicated threads. This s3 plugin has partial support for workers. The plugin can only support a single worker; enabling multiple workers will lead to errors/indeterminate behavior.
Example:
If you enable a single worker, you are enabling a dedicated thread for your S3 output. We recommend starting without workers, evaluating the performance, and then enabling a worker if needed. For most users, the plugin can provide sufficient throughput without workers.
Example:
Then, the records will be stored into the MinIO server.
In order to send records into Amazon S3, you can run the plugin from the command line or through the configuration file.
The s3 plugin, can read the parameters from the command line through the -p argument (property), e.g:
In your main configuration file append the following Output section:
An example that using PutObject instead of multipart:
Amazon distributes a container image with Fluent Bit and this plugins.
Our images are available in Amazon ECR Public Gallery. You can download images with different tags by following command:
For example, you can pull the image with latest version by:
If you see errors for image pull limits, try log into public ECR with your AWS credentials:
You can use our SSM Public Parameters to find the Amazon ECR image URI in your region:
To use this feature, FLB_ARROW must be turned on at compile time:
Once compiled, Fluent Bit can upload incoming data to S3 in Apache Arrow format. For example:
As shown in this example, setting Compression to arrow makes Fluent Bit to convert payload into Apache Arrow format.
The stored data is very easy to load, analyze and process using popular data processing tools (such as Python pandas, Apache Spark and Tensorflow). The following code uses pyarrow to analyze the uploaded data:
The nats output plugin, allows to flush your records into a end point. The following instructions assumes that you have a fully operational NATS Server in place.
In order to flush records, the nats plugin requires to know two parameters:
| parameter | description | default |
|---|
In order to override the default configuration values, the plugin uses the optional Fluent Bit network address format, e.g:
only requires to know that it needs to use the nats output plugin, if no extra information is given, it will use the default values specified in the above table.
As described above, the target service and storage point can be changed, e.g:
For every set of records flushed to a NATS Server, Fluent Bit uses the following JSON format:
Each record is an individual entity represented in a JSON array that contains a UNIX_TIMESTAMP and a JSON map with a set of key/values. A summarized output of the CPU input plugin will looks as this:
The kafka-rest output plugin, allows to flush your records into a server. The following instructions assumes that you have a fully operational Kafka REST Proxy and Kafka services running in your environment.
| Key | Description | default |
|---|
Kafka REST Proxy output plugin supports TTL/SSL, for more details about the properties available and general configuration, please refer to the section.
In order to insert records into a Kafka REST Proxy service, you can run the plugin from the command line or through the configuration file:
The kafka-rest plugin, can read the parameters from the command line in two ways, through the -p argument (property), e.g:
In your main configuration file append the following Input & Output sections:
is an intuitive cloud based log management system that provides you an easy interface to query your logs once they are stored.
The Fluent Bit logdna output plugin allows you to send your log or events to a compliant service like:
Before to get started with the plugin configuration, make sure to obtain the proper account to get access to the service. You can start with a free trial in the following link:
| Key | Description | Default |
|---|
One of the features of Fluent Bit + LogDNA integration is the ability to auto enrich each record with further context.
When the plugin process each record (or log), it tries to lookup for specific key names that might contain specific context for the record in question, the following table describe the keys and the discovery logic:
The following configuration example, will emit a dummy example record and ingest it on LogDNA. Copy and paste the following content in a file called logdna.conf:
run Fluent Bit with the new configuration file:
Fluent Bit output:
Your record will be available and visible in your LogDNA dashboard after a few seconds.
In your LogDNA dashboard, go to the top filters and mark the Tags aa and bb, then you will be able to see your records as the example below:
The Apache SkyWalking output plugin, allows to flush your records to a OAP. The following instructions assumes that you have a fully operational Apache SkyWalking OAP in place.
| parameter | description | default |
|---|
Apache SkyWalking output plugin supports TTL/SSL, for more details about the properties available and general configuration, please refer to the section.
In order to start inserting records into an Apache SkyWalking service, you can run the plugin through the configuration file:
In your main configuration file append the following Input & Output sections:
For example, if we get log as follows,
This message is packed into the following protocol format and written to the OAP via the REST API.
| Key | Description | Default |
|---|---|---|
| Key | Description |
|---|---|
| Key | Description |
|---|---|
| Key | Description | default |
|---|
If you get a 403 Forbidden error response, double check that you have a valid and that you have .
| Key | Description |
|---|
You can check the for more details.
For more see .
When using Secure Forward mode, the mode requires to be enabled. The following additional configuration parameters are available:
| Key | Description | Default |
|---|
Before proceeding, make sure that is installed, if it's not the case please refer to the following document and go ahead with that.
Once is installed, create the following configuration file example that will allow us to stream data into it:
In one terminal launch specifying the new configuration file created:
Now that is ready to receive messages, we need to specify where the forward output plugin will flush the information using the following format:
If the TAG parameter is not set, the plugin will retain the tag. Keep in mind that TAG is important for routing rules inside .
Using the input plugin as an example we will flush CPU metrics to with tag fluent_bit:
Now on the side, you will see the CPU metrics gathered in the last seconds:
So we gathered metrics and flushed them out to properly.
Secure Forward aims to provide a secure channel of communication with the remote Fluentd service using .
If you're using , this parser can parse time and use it as timestamp of message. If all above fail, Fluent Bit tries to get timestamp extracted by your parser.
Your log timestamp has to be in format. If the Gelf_Timestamp_Key value of your log is not in this format, your Graylog server will ignore it.
If you're using Fluent Bit in Kubernetes and you're using , this plugin adds host value to your log by default, and you don't need to add it by your own.
If you use and use a Parser like the docker parser shown above, it decodes your message and extracts data (and any other present) field. This is how this log in looks like after decoding:
The , unnests fields inside log key. In our example, it puts data alongside stream and time.
adds host name.
Any custom field (not present in ) is prefixed by an underline.
| Key | Description | default |
|---|
See Google's for further details.
HTTP output plugin supports TTL/SSL, for more details about the properties available and general configuration, please refer to the section.
A sample Sumo Logic query for the input. (Requires json_lines format with iso8601 date format for the timestamp field).
| Key | Description |
|---|
| Key | Description |
|---|
| Key | Description |
|---|
See for details on how AWS credentials are fetched.
NOTE: The outputted by Fluent Bit's built-in http server are meaningless for the S3 output. This is because S3 has its own buffering and retry mechanisms. The Fluent Bit AWS S3 maintainers apologize for this feature gap; you can .
| Key | Description | Default |
|---|
To skip TLS verification, set tls.verify as false. For more details about the properties available and general configuration, please refer to the section.
The HTTP Monitoring interface output metrics are not meaningful for S3: AWS understands that this is non-ideal; we have that will allow S3 to manage its own output metrics.
There is one minor drawback to multipart uploads- the file and data will not be visible in S3 until the upload is completed with a call. The plugin will attempt to make this call whenever Fluent Bit is shut down to ensure your data is available in s3. It will also store metadata about each upload in the store_dir, ensuring that uploads can be completed when Fluent Bit restarts (assuming it has access to persistent disk and the store_dir files will still be present on restart).
If you run Fluent Bit in an environment without persistent disk, or without the ability to restart Fluent Bit and give it access to the data stored in the store_dir from previous executions- some considerations apply. This might occur if you run Fluent Bit on .
is a high-performance, S3 compatible object storage and you can build your app with S3 functionality without S3.
Assume you run at localhost:9000, and create a bucket of your-bucket by referring .
You can check the for more details.
For more see .
Starting from Fluent Bit v1.8, the Amazon S3 plugin includes the support for . The support is currently not enabled by default, as it depends on a shared version of libarrow as the prerequisite.
| Key | Description |
|---|
The format of the plugin output follows the .
region
The AWS region.
stream
The name of the Kinesis Streams Delivery stream that you want log records sent to.
time_key
Add the timestamp to the record under this key. By default the timestamp from Fluent Bit will not be added to records sent to Kinesis.
time_key_format
strftime compliant format string for the timestamp; for example, the default is '%Y-%m-%dT%H:%M:%S'. Supports millisecond precision with '%3N' and supports nanosecond precision with '%9N' and '%L'; for example, adding '%3N' to support millisecond '%Y-%m-%dT%H:%M:%S.%3N'. This option is used with time_key.
log_key
By default, the whole log record will be sent to Kinesis. If you specify a key name with this option, then only the value of that key will be sent to Kinesis. For example, if you are using the Fluentd Docker log driver, you can specify log_key log and only the log message will be sent to Kinesis.
role_arn
ARN of an IAM role to assume (for cross account access).
endpoint
Specify a custom endpoint for the Kinesis API.
sts_endpoint
Custom endpoint for the STS API.
auto_retry_requests
Immediately retry failed requests to AWS services once. This option does not affect the normal Fluent Bit retry mechanism with backoff. Instead, it enables an immediate retry with no delay for networking errors, which may help improve throughput when there are transient/random networking issues. This option defaults to true.
external_id
Specify an external ID for the STS API, can be used with the role_arn parameter if your role requires an external ID.
tenant_id
Required - The tenant/domain ID of the AAD registered application.
client_id
Required - The client ID of the AAD registered application.
client_secret
Required - The client secret of the AAD registered application (App Secret).
ingestion_endpoint
Required - The cluster's ingestion endpoint, usually in the form `https://ingest-cluster_name.region.kusto.windows.net
database_name
Required - The database name.
table_name
Required - The table name.
ingestion_mapping_reference
Optional - The name of a JSON ingestion mapping that will be used to map the ingested payload into the table columns.
log_key
Key name of the log content.
log
include_tag_key
If enabled, a tag is appended to output. The key name is used tag_key property.
On
tag_key
The key name of tag. If include_tag_key is false, This property is ignored.
tag
include_time_key
If enabled, a timestamp is appended to output. The key name is used time_key property.
On
time_key
The key name of time. If include_time_key is false, This property is ignored.
timestamp
account_name
Azure Storage account name. This configuration property is mandatory
shared_key
Specify the Azure Storage Shared Key to authenticate against the service. This configuration property is mandatory.
container_name
Name of the container that will contain the blobs. This configuration property is mandatory
blob_type
Specify the desired blob type. Fluent Bit supports appendblob and blockblob.
appendblob
auto_create_container
If container_name does not exist in the remote service, enabling this option will handle the exception and auto-create the container.
on
path
Optional path to store your blobs. If your blob name is myblob, you can specify sub-directories where to store it using path, so setting path to /logs/kubernetes will store your blob in /logs/kubernetes/myblob.
emulator_mode
If you want to send data to an Azure emulator service like Azurite, enable this option so the plugin will format the requests to the expected format.
off
endpoint
If you are using an emulator, this option allows you to specify the absolute HTTP address of such service. e.g: http://127.0.0.1:10000.
tls
Enable or disable TLS encryption. Note that Azure service requires this to be turned on.
off
region
The AWS region.
log_group_name
The name of the CloudWatch Log Group that you want log records sent to.
log_group_template
Template for Log Group name using Fluent Bit record_accessor syntax. This field is optional and if configured it overrides the log_group_name. If the template translation fails, an error is logged and the log_group_name (which is still required) is used instead. See the tutorial below for an example.
log_stream_name
The name of the CloudWatch Log Stream that you want log records sent to.
log_stream_prefix
Prefix for the Log Stream name. The tag is appended to the prefix to construct the full log stream name. Not compatible with the log_stream_name option.
log_stream_template
Template for Log Stream name using Fluent Bit record_accessor syntax. This field is optional and if configured it overrides the other log stream options. If the template translation fails, an error is logged and the log_stream_name or log_stream_prefix are used instead (and thus one of those fields is still required to be configured). See the tutorial below for an example.
log_key
By default, the whole log record will be sent to CloudWatch. If you specify a key name with this option, then only the value of that key will be sent to CloudWatch. For example, if you are using the Fluentd Docker log driver, you can specify log_key log and only the log message will be sent to CloudWatch.
log_format
An optional parameter that can be used to tell CloudWatch the format of the data. A value of json/emf enables CloudWatch to extract custom metrics embedded in a JSON payload. See the Embedded Metric Format.
role_arn
ARN of an IAM role to assume (for cross account access).
auto_create_group
Automatically create the log group. Valid values are "true" or "false" (case insensitive). Defaults to false.
log_retention_days
If set to a number greater than zero, and newly create log group's retention policy is set to this many days. Valid values are: [1, 3, 5, 7, 14, 30, 60, 90, 120, 150, 180, 365, 400, 545, 731, 1827, 3653]
endpoint
Specify a custom endpoint for the CloudWatch Logs API.
metric_namespace
An optional string representing the CloudWatch namespace for the metrics. See Metrics Tutorial section below for a full configuration.
metric_dimensions
A list of lists containing the dimension keys that will be applied to all metrics. The values within a dimension set MUST also be members on the root-node. For more information about dimensions, see Dimension and Dimensions. In the fluent-bit config, metric_dimensions is a comma and semicolon separated string. If you have only one list of dimensions, put the values as a comma separated string. If you want to put list of lists, use the list as semicolon separated strings. For example, if you set the value as 'dimension_1,dimension_2;dimension_3', we will convert it as [[dimension_1, dimension_2],[dimension_3]]
sts_endpoint
Specify a custom STS endpoint for the AWS STS API.
auto_retry_requests
Immediately retry failed requests to AWS services once. This option does not affect the normal Fluent Bit retry mechanism with backoff. Instead, it enables an immediate retry with no delay for networking errors, which may help improve throughput when there are transient/random networking issues. This option defaults to true.
external_id
Specify an external ID for the STS API, can be used with the role_arn parameter if your role requires an external ID.
Customer_ID | Customer ID or WorkspaceID string. |
Shared_Key | The primary or the secondary Connected Sources client authentication key. |
Log_Type | The name of the event type. | fluentbit |
Time_Key | Optional parameter to specify the key name where the timestamp will be stored. | @timestamp |
Time_Generated | If enabled, the HTTP request header 'time-generated-field' will be included so Azure can override the timestamp with the key specified by 'time_key' option. | off |
region | The AWS region. |
delivery_stream | The name of the Kinesis Firehose Delivery stream that you want log records sent to. |
time_key | Add the timestamp to the record under this key. By default the timestamp from Fluent Bit will not be added to records sent to Kinesis. |
time_key_format | strftime compliant format string for the timestamp; for example, the default is '%Y-%m-%dT%H:%M:%S'. Supports millisecond precision with '%3N' and supports nanosecond precision with '%9N' and '%L'; for example, adding '%3N' to support millisecond '%Y-%m-%dT%H:%M:%S.%3N'. This option is used with time_key. |
log_key | By default, the whole log record will be sent to Firehose. If you specify a key name with this option, then only the value of that key will be sent to Firehose. For example, if you are using the Fluentd Docker log driver, you can specify |
compression | Compression type for Firehose records. Each log record is individually compressed and sent to Firehose. 'gzip' and 'arrow' are the supported values. 'arrow' is only an available if Apache Arrow was enabled at compile time. Defaults to no compression. |
role_arn | ARN of an IAM role to assume (for cross account access). |
endpoint | Specify a custom endpoint for the Firehose API. |
sts_endpoint | Custom endpoint for the STS API. |
auto_retry_requests | Immediately retry failed requests to AWS services once. This option does not affect the normal Fluent Bit retry mechanism with backoff. Instead, it enables an immediate retry with no delay for networking errors, which may help improve throughput when there are transient/random networking issues. This option defaults to |
external_id | Specify an external ID for the STS API, can be used with the role_arn parameter if your role requires an external ID. |
Shared_Key | A key string known by the remote Fluentd used for authorization. |
Empty_Shared_Key | Use this option to connect to Fluentd with a zero-length secret. | False |
Username | Specify the username to present to a Fluentd server that enables |
Password | Specify the password corresponding to the username. |
Self_Hostname | Default value of the auto-generated certificate common name (CN). | localhost |
tls | Enable or disable TLS support | Off |
tls.verify | Force certificate validation | On |
tls.debug | Set TLS debug verbosity level. It accept the following values: 0 (No debug), 1 (Error), 2 (State change), 3 (Informational) and 4 Verbose | 1 |
tls.ca_file | Absolute path to CA certificate file |
tls.crt_file | Absolute path to Certificate file. |
tls.key_file | Absolute path to private Key file. |
tls.key_passwd | Optional password for tls.key_file file. |
google_service_credentials | Absolute path to a Google Cloud credentials JSON file. | Value of the environment variable $GOOGLE_SERVICE_CREDENTIALS |
project_id | The project id containing the BigQuery dataset to stream into. | The value of the |
dataset_id | The dataset id of the BigQuery dataset to write into. This dataset must exist in your project. |
table_id | The table id of the BigQuery table to write into. This table must exist in the specified dataset and the schema must match the output. |
skip_invalid_rows | Insert all valid rows of a request, even if invalid rows exist. The default value is false, which causes the entire request to fail if any invalid rows exist. | Off |
ignore_unknown_values | Accept rows that contain values that do not match the schema. The unknown values are ignored. Default is false, which treats unknown values as errors. | Off |
enable_workload_identity_federation | Enables workload identity federation as an alternative authentication method. Cannot be used with service account credentials file or environment variable. AWS is the only identity provider currently supported. | Off |
aws_region | Used to construct a regional endpoint for AWS STS to verify AWS credentials obtained by Fluent Bit. Regional endpoints are recommended by AWS. |
project_number | GCP project number where the identity provider was created. Used to construct the full resource name of the identity provider. |
pool_id | GCP workload identity pool where the identity provider was created. Used to construct the full resource name of the identity provider. |
provider_id | GCP workload identity provider. Used to construct the full resource name of the identity provider. Currently only AWS accounts are supported. |
google_service_account | Email address of the Google service account to impersonate. The workload identity provider must have permissions to impersonate this service account, and the service account must have permissions to access Google BigQuery resources (e.g. |
Delimiter | The character to separate each data. Default: ',' |
Delimiter | The character to separate each pair. Default: '\t'(TAB) |
Label_Delimiter | The character to separate label and the value. Default: ':' |
Template | The format string. Default: '{time} {message}' |
level | If the record contains a key called |
file | if the record contains a key called |
app | If the record contains a key called |
meta | if the record contains a key called |
Host | IP address or hostname of the target Kafka REST Proxy server | 127.0.0.1 |
Port | TCP port of the target Kafka REST Proxy server | 8082 |
Topic | Set the Kafka topic | fluent-bit |
Partition | Set the partition number (optional) |
Message_Key | Set a message key (optional) |
Time_Key | The Time_Key property defines the name of the field that holds the record timestamp. | @timestamp |
Time_Key_Format | Defines the format of the timestamp. | %Y-%m-%dT%H:%M:%S |
Include_Tag_Key | Append the Tag name to the final record. | Off |
Tag_Key | If Include_Tag_Key is enabled, this property defines the key name for the tag. | _flb-key |
logdna_host | LogDNA API host address | logs.logdna.com |
logdna_port | LogDNA TCP Port | 443 |
api_key | API key to get access to the service. This property is mandatory. |
hostname | Name of the local machine or device where Fluent Bit is running. When this value is not set, Fluent Bit lookup the hostname and auto populate the value. If it cannot be found, an |
mac | Mac address. This value is optional. |
ip | IP address of the local hostname. This value is optional. |
tags | A list of comma separated strings to group records in LogDNA and simplify the query with filters. |
file | Optional name of a file being monitored. Note that this value is only set if the record do not contain a reference to it. |
app | Name of the application. This value is auto discovered on each record, if not found, the default value is used. | Fluent Bit |
host | Hostname of Apache SkyWalking OAP | 127.0.0.1 |
port | TCP port of the Apache SkyWalking OAP | 12800 |
auth_token | Authentication token if needed for Apache SkyWalking OAP | None |
svc_name | Service name that fluent-bit belongs to | sw-service |
svc_inst_name | Service instance name of fluent-bit | fluent-bit |
Unit | The unit of duration. (second/minute/hour/day) | minute |
Path | Directory path to store files. If not set, Fluent Bit will write the files on it's own positioned directory. note: this option was added on Fluent Bit v1.4.6 |
File | Set file name to store the records. If not set, the file name will be the tag associated with the records. |
Format | The format of the file content. See also Format section. Default: out_file. |
Mkdir | Recursively create output directory if it does not exist. Permissions set to 0755. |
Workers | Enables dedicated thread(s) for this output. Default value is set since version 1.8.13. For previous versions is 0. | 1 |
host | IP address or hostname of the NATS Server | 127.0.0.1 |
port | TCP port of the target NATS Server | 4222 |
The null output plugin just throws away events.
The plugin doesn't support configuration parameters.
You can run the plugin from the command line or through the configuration file:
From the command line you can let Fluent Bit throws away events with the following options:
In your main configuration file append the following Input & Output sections:
Host | Required - The Datadog server where you are sending your logs. |
|
TLS | Required - End-to-end security communications security protocol. Datadog recommends setting this to |
|
compress | Recommended - compresses the payload in GZIP format, Datadog supports and recommends setting this to |
apikey |
Proxy |
provider | To activate the remapping, specify configuration flag provider with value |
json_date_key | Date key name for output. |
|
include_tag_key | If enabled, a tag is appended to output. The key name is used |
|
tag_key | The key name of tag. If |
|
dd_service | Recommended - The human readable name for your service generating the logs - the name of your application or database. |
dd_source | Recommended - A human readable name for the underlying technology of your service. For example, |
dd_tags |
dd_message_key | By default, the plugin searches for the key 'log' and remap the value to the key 'message'. If the property is set, the plugin will search the property name key. |
Host | Target host where Fluent-Bit or Fluentd are listening for Forward messages. | 127.0.0.1 |
Port | TCP Port of the target service. | 24224 |
Time_as_Integer | Set timestamps in integer format, it enable compatibility mode for Fluentd v0.12 series. | False |
Upstream |
Unix_Path | Specify the path to unix socket to send a Forward message. If set, |
Tag | Overwrite the tag as we transmit. This allows the receiving pipeline start fresh, or to attribute source. |
Send_options | Always send options (with "size"=count of messages) | False |
Require_ack_response | Send "chunk"-option and wait for "ack" response from server. Enables at-least-once and receiving server can control rate of traffic. (Requires Fluentd v0.14.0+ server) | False |
Compress |
Workers | Enables dedicated thread(s) for this output. Default value is set since version 1.8.13. For previous versions is 0. | 2 |
Match | Pattern to match which tags of logs to be outputted by this plugin |
Host | IP address or hostname of the target Graylog server | 127.0.0.1 |
Port | The port that your Graylog GELF input is listening on | 12201 |
Mode | The protocol to use ( | udp |
Gelf_Short_Message_Key | A short descriptive message (MUST be set in GELF) | short_message |
Gelf_Timestamp_Key | Your log timestamp (SHOULD be set in GELF) | timestamp |
Gelf_Host_Key | Key which its value is used as the name of the host, source or application that sent this message. (MUST be set in GELF) | host |
Gelf_Full_Message_Key | Key to use as the long message that can i.e. contain a backtrace. (Optional in GELF) | full_message |
Gelf_Level_Key | level |
Packet_Size | If transport protocol is | 1420 |
Compress | If transport protocol is | true |
host | IP address or hostname of the target HTTP Server | 127.0.0.1 |
http_User | Basic Auth Username |
http_Passwd | Basic Auth Password. Requires HTTP_User to be set |
AWS_Auth | Enable AWS SigV4 authentication | false |
AWS_Service | Specify the AWS service code, i.e. es, xray, etc., of your service, used by SigV4 authentication. Usually can be found in the service endpoint's subdomains, |
AWS_Region | Specify the AWS region of your service, used by SigV4 authentication |
AWS_STS_Endpoint | Specify the custom sts endpoint to be used with STS API, used with the AWS_Role_ARN option, used by SigV4 authentication |
AWS_Role_ARN | AWS IAM Role to assume, used by SigV4 authentication |
AWS_External_ID | External ID for the AWS IAM Role specified with |
port | TCP port of the target HTTP Server | 80 |
Proxy |
uri | Specify an optional HTTP URI for the target web server, e.g: /something | / |
compress | Set payload compression mechanism. Option available is 'gzip' |
format | Specify the data format to be used in the HTTP request body, by default it uses msgpack. Other supported formats are json, json_stream and json_lines and gelf. | msgpack |
allow_duplicated_headers | Specify if duplicated headers are allowed. If a duplicated header is found, the latest key/value set is preserved. | true |
log_response_payload | Specify if the response paylod should be logged or not. | true |
header_tag | Specify an optional HTTP header field for the original message tag. |
header | Add a HTTP header key/value pair. Multiple headers can be set. |
json_date_key | Specify the name of the time key in the output record. To disable the time key just set the value to | date |
json_date_format | Specify the format of the date. Supported formats are double, epoch, iso8601 (eg: 2018-05-30T09:39:52.000681Z) and java_sql_timestamp (eg: 2018-05-30 09:39:52.000681) | double |
gelf_timestamp_key | Specify the key to use for |
gelf_host_key | Specify the key to use for the |
gelf_short_message_key | Specify the key to use as the |
gelf_full_message_key | Specify the key to use for the |
gelf_level_key | Specify the key to use for the |
body_key | Specify the key to use as the body of the request (must prefix with "$"). The key must contain either a binary or raw string, and the content type can be specified using headers_key (which must be passed whenever body_key is present). When this option is present, each msgpack record will create a separate request. |
headers_key | Specify the key to use as the headers of the request (must prefix with "$"). The key must contain a map, which will have the contents merged on the request headers. This can be used for many purposes, such as specifying the content-type of the data contained in body_key. |
Workers | Enables dedicated thread(s) for this output. Default value is set since version 1.8.13. For previous versions is 0. | 2 |
region | The AWS region of your S3 bucket | us-east-1 |
bucket | S3 Bucket name | None |
json_date_key | Specify the name of the time key in the output record. To disable the time key just set the value to | date |
json_date_format | Specify the format of the date. Supported formats are double, epoch, iso8601 (eg: 2018-05-30T09:39:52.000681Z) and java_sql_timestamp (eg: 2018-05-30 09:39:52.000681) | iso8601 |
total_file_size | Specifies the size of files in S3. Minimum size is 1M. With | 100M |
upload_chunk_size | The size of each 'part' for multipart uploads. Max: 50M | 5,242,880 bytes |
upload_timeout | Whenever this amount of time has elapsed, Fluent Bit will complete an upload and create a new file in S3. For example, set this value to 60m and you will get a new file every hour. | 10m |
store_dir | Directory to locally buffer data before sending. When multipart uploads are used, data will only be buffered until the | /tmp/fluent-bit/s3 |
store_dir_limit_size | The size of the limitation for disk usage in S3. Limit the amount of s3 buffers in the | 0, which means unlimited |
s3_key_format | Format string for keys in S3. This option supports a UUID, strftime time formatters, a syntax for selecting parts of the Fluent log tag using a syntax inspired by the rewrite_tag filter. Add $UUID in the format string to insert a random string. Add $INDEX in the format string to insert an integer that increments each upload. The $INDEX value will be saved in the store_dir so that if Fluent Bit restarts the value will keep incrementing from the previous run. Add $TAG in the format string to insert the full log tag; add $TAG[0] to insert the first part of the tag in the s3 key. The tag is split into “parts” using the characters specified with the | /fluent-bit-logs/$TAG/%Y/%m/%d/%H/%M/%S |
s3_key_format_tag_delimiters | A series of characters which will be used to split the tag into 'parts' for use with the s3_key_format option. See the in depth examples and tutorial in the documentation. | . |
static_file_path | Disables behavior where UUID string is automatically appended to end of S3 key name when $UUID is not provided in s3_key_format. $UUID, time formatters, $TAG, and other dynamic key formatters all work as expected while this feature is set to true. | false |
use_put_object | Use the S3 PutObject API, instead of the multipart upload API. When this option is on, key extension is only available when $UUID is specified in | false |
role_arn | ARN of an IAM role to assume (ex. for cross account access). | None |
endpoint | Custom endpoint for the S3 API. An endpoint can contain scheme and port. | None |
sts_endpoint | Custom endpoint for the STS API. | None |
canned_acl | None |
compression | Compression type for S3 objects. 'gzip' is currently the only supported value by default. If Apache Arrow support was enabled at compile time, you can also use 'arrow'. For gzip compression, the Content-Encoding HTTP Header will be set to 'gzip'. Gzip compression can be enabled when | None |
content_type | A standard MIME type for the S3 object; this will be set as the Content-Type HTTP header. | None |
send_content_md5 | Send the Content-MD5 header with PutObject and UploadPart requests, as is required when Object Lock is enabled. | false |
auto_retry_requests | Immediately retry failed requests to AWS services once. This option does not affect the normal Fluent Bit retry mechanism with backoff. Instead, it enables an immediate retry with no delay for networking errors, which may help improve throughput when there are transient/random networking issues. | true |
log_key | By default, the whole log record will be sent to S3. If you specify a key name with this option, then only the value of that key will be sent to S3. For example, if you are using Docker, you can specify log_key log and only the log message will be sent to S3. | None |
preserve_data_ordering | Normally, when an upload request fails, there is a high chance for the last received chunk to be swapped with a later chunk, resulting in data shuffling. This feature prevents this shuffling by using a queue logic for uploads. | true |
storage_class | None |
retry_limit | Integer value to set the maximum number of retries allowed. Note: this configuration is released since version 1.9.10 and 2.0.1. For previous version, the number of retries is 5 and is not configurable. | 1 |
external_id | Specify an external ID for the STS API, can be used with the role_arn parameter if your role requires an external ID. | None |
New Relic is a data management platform that gives you real-time insights of your data for developers, operations and management teams.
The Fluent Bit nrlogs output plugin allows you to send your logs to New Relic service.
Before to get started with the plugin configuration, make sure to obtain the proper account to get access to the service. You can register and start with a free trial in the following link:
The following configuration example, will emit a dummy example record and ingest it on New Relic. Copy and paste the following content in a file called newrelic.conf:
run Fluent Bit with the new configuration file:
Fluent Bit output:
Observe employs the http output plugin, allowing you to flush your records into Observe.
For now the functionality is pretty basic and it issues a POST request with the data records in MessagePack (or JSON) format.
The following are the specific HTTP parameters to employ:
| Key | Description | default |
|---|---|---|
In your main configuration file, append the following Input & Output sections:
Kafka output plugin allows to ingest your records into an Apache Kafka service. This plugin use the official librdkafka C library (built-in dependency)
| Key | Description | default |
|---|---|---|
Setting
rdkafka.log.connection.closetofalseandrdkafka.request.required.acksto 1 are examples of recommended settings of librdfkafka properties.
In order to insert records into Apache Kafka, you can run the plugin from the command line or through the configuration file:
The kafka plugin, can read the parameters from the command line in two ways, through the -p argument (property), e.g:
In your main configuration file append the following Input & Output sections:
Fluent-bit comes with support for avro encoding for the out_kafka plugin. Avro support is optional and must be activated at build-time by using a build def with cmake: -DFLB_AVRO_ENCODER=On such as in the following example which activates:
out_kafka with avro encoding
fluent-bit's prometheus
metrics via an embedded http endpoint
debugging support
builds the test suites
This is example fluent-bit config tails kubernetes logs, decorates the log lines with kubernetes metadata via the kubernetes filter, and then sends the fully decorated log lines to a kafka broker encoded with a specific avro schema.
Send logs to Amazon OpenSearch Service
The opensearch output plugin, allows to ingest your records into an OpenSearch database. The following instructions assumes that you have a fully operational OpenSearch service running in your environment.
| Key | Description | default |
|---|---|---|
The parameters index and type can be confusing if you are new to OpenSearch, if you have used a common relational database before, they can be compared to the database and table concepts. Also see the FAQ below
OpenSearch output plugin supports TTL/SSL, for more details about the properties available and general configuration, please refer to the TLS/SSL section.
The write_operation can be any of:
Please note, Id_Key or Generate_ID is required in update, and upsert scenario.
In order to insert records into an OpenSearch service, you can run the plugin from the command line or through the configuration file:
The opensearch plugin, can read the parameters from the command line in two ways, through the -p argument (property) or setting them directly through the service URI. The URI format is the following:
Using the format specified, you could start Fluent Bit through:
which is similar to do:
In your main configuration file append the following Input & Output sections. You can visualize this configuration here
Some input plugins may generate messages where the field names contains dots. This opensearch plugin replaces them with an underscore, e.g:
becomes
The Amazon OpenSearch Service adds an extra security layer where HTTP requests must be signed with AWS Sigv4. This plugin supports Amazon OpenSearch Service with IAM Authentication.
See here for details on how AWS credentials are fetched.
Example configuration:
Notice that the Port is set to 443, tls is enabled, and AWS_Region is set.
Similarly to Elastic Cloud, OpenSearch in version 2.0 and above needs to have type option being removed by setting Suppress_Type_Name On.
Without this you will see errors like:
Amazon OpenSearch Serverless is an offering that eliminates your need to manage OpenSearch clusters. All existing Fluent Bit OpenSearch output plugin options work with OpenSearch Serverless. For Fluent Bit, the only difference is that you must specify the service name as aoss (Amazon OpenSearch Serverless) when you enable AWS_Auth:
Data Access Permissions
When sending logs to OpenSearch Serverless, your AWS IAM entity needs OpenSearch Serverless Data Access permisions. Give your IAM entity the following data access permissions to your serverless collection:
With data access permissions, IAM policies are not needed to access the collection.
An output plugin to submit Logs, Metrics, or Traces to an OpenTelemetry endpoint
The OpenTelemetry plugin allows you to take logs, metrics, and traces from Fluent Bit and submit them to an OpenTelemetry HTTP endpoint.
Important Note: At the moment only HTTP endpoints are supported.
| Key | Description | Default |
|---|---|---|
The OpenTelemetry plugin works with logs and only the metrics collected from one of the metric input plugins. In the following example, log records generated by the dummy plugin and the host metrics collected by the node exporter metrics plugin are exported by the OpenTelemetry output plugin.
The influxdb output plugin, allows to flush your records into a InfluxDB time series database. The following instructions assumes that you have a fully operational InfluxDB service running in your system.
| Key | Description | default |
|---|---|---|
InfluxDB output plugin supports TTL/SSL, for more details about the properties available and general configuration, please refer to the TLS/SSL section.
In order to start inserting records into an InfluxDB service, you can run the plugin from the command line or through the configuration file:
The influxdb plugin, can read the parameters from the command line in two ways, through the -p argument (property) or setting them directly through the service URI. The URI format is the following:
Using the format specified, you could start Fluent Bit through:
In your main configuration file append the following Input & Output sections:
Basic example of Tag_Keys usage:
With Auto_Tags=On in this example cause error, because every parsed field value type is string. Best usage of this option in metrics like record where one or more field value is not string typed.
Basic example of Tags_List_Key usage:
Before to start Fluent Bit, make sure the target database exists on InfluxDB, using the above example, we will insert the data into a fluentbit database.
Log into InfluxDB console:
Create the database:
Check the database exists:
The following command will gather CPU metrics from the system and send the data to InfluxDB database every five seconds:
Note that all records coming from the cpu input plugin, have a tag cpu, this tag is used to generate the measurement in InfluxDB
From InfluxDB console, choose your database:
Now query some specific fields:
The CPU input plugin gather more metrics per CPU core, in the above example we just selected three specific metrics. The following query will give a full result:
Query tagged keys:
And now query method key values:
Loki is multi-tenant log aggregation system inspired by Prometheus. It is designed to be very cost effective and easy to operate.
The Fluent Bit loki built-in output plugin allows you to send your log or events to a Loki service. It supports data enrichment with Kubernetes labels, custom label keys and Tenant ID within others.
Be aware there is a separate Golang output plugin provided by Grafana with different configuration options.
| Key | Description | Default |
|---|---|---|
Loki store the record logs inside Streams, a stream is defined by a set of labels, at least one label is required.
Fluent Bit implements a flexible mechanism to set labels by using fixed key/value pairs of text but also allowing to set as labels certain keys that exists as part of the records that are being processed. Consider the following JSON record (pretty printed for readability):
If you decide that your Loki Stream will be composed by two labels called job and the value of the record key called stream , your labels configuration properties might look as follows:
As you can see the label job has the value fluentbit and the second label is configured to access the nested map called sub targeting the value of the key stream . Note that the second label name must starts with a $, that means that's a Record Accessor pattern so it provide you the ability to retrieve values from nested maps by using the key names.
When processing above's configuration, internally the ending labels for the stream in question becomes:
Another feature of Labels management is the ability to provide custom key names, using the same record accessor pattern we can specify the key name manually and let the value to be populated automatically at runtime, e.g:
When processing that new configuration, the internal labels will be:
label_keys propertyThe additional configuration property called label_keys allow to specify multiple record keys that needs to be placed as part of the outgoing Stream Labels, yes, this is a similar feature than the one explained above in the labels property. Consider this as another way to set a record key in the Stream, but with the limitation that you cannot use a custom name for the key value.
The following configuration examples generate the same Stream Labels:
the above configuration accomplish the same than this one:
both will generate the following Streams label:
label_map_path propertyThe configuration property label_map_path is to read a JSON file that defines how to extract labels from each record.
The file should contain a JSON object. Each keys define how to get label value from a nested record. Each values are used as label names.
The following configuration examples generate the same Stream Labels:
map.json:
The following configuration examples generate the same Stream Labels:
the above configuration accomplish the same than this one:
both will generate the following Streams label:
Note that if you are running in a Kubernetes environment, you might want to enable the option auto_kubernetes_labels which will auto-populate the streams with the Pod labels for you. Consider the following configuration:
Based in the JSON example provided above, the internal stream labels will be:
This plugin inherit core Fluent Bit features to customize the network behavior and optionally enable TLS in the communication channel. For more details about the specific options available refer to the following articles:
Networking Setup: timeouts, keepalive and source address
Security & TLS: all about TLS configuration and certificates
Note that all options mentioned in the articles above must be enabled in the plugin configuration in question.
Fluent Bit supports sending logs (and metrics) to Grafana Cloud by providing the appropriate URL and ensuring TLS is enabled.
An example configuration - make sure to set the credentials and ensure the host URL matches the correct one for your deployment:
The following configuration example, will emit a dummy example record and ingest it on Loki . Copy and paste the following content into a file called out_loki.conf:
run Fluent Bit with the new configuration file:
Fluent Bit output:
An output plugin to submit Prometheus Metrics using the remote write protocol
The prometheus remote write plugin allows you to take metrics from Fluent Bit and submit them to a Prometheus server through the remote write mechanism.
Important Note: The prometheus exporter only works with metric plugins, such as Node Exporter Metrics
| Key | Description | Default |
|---|
The Prometheus remote write plugin only works with metrics collected by one of the from metric input plugins. In the following example, host metrics are collected by the node exporter metrics plugin and then delivered by the prometheus remote write output plugin.
The following are examples of using Prometheus remote write with hosted services below
An output plugin to expose Prometheus Metrics
The prometheus exporter allows you to take metrics from Fluent Bit and expose them such that a Prometheus instance can scrape them.
Important Note: The prometheus exporter only works with metric plugins, such as Node Exporter Metrics
| Key | Description | Default |
|---|
The Prometheus exporter only works with metrics captured from metric plugins. In the following example, host metrics are captured by the node exporter metrics plugin and then are routed to prometheus exporter. Within the output plugin two labels are added app="fluent-bit"and color="blue"
is a very popular and versatile open source database management system that supports the SQL language and that is capable of storing both structured and unstructured data, such as JSON objects.
Given that Fluent Bit is designed to work with JSON objects, the pgsql output plugin allows users to send their data to a PostgreSQL database and store it using the JSONB type.
PostgreSQL 9.4 or higher is required.
According to the parameters you have set in the configuration file, the plugin will create the table defined by the table option in the database defined by the database option hosted on the server defined by the host option. It will use the PostgreSQL user defined by the user option, which needs to have the right privileges to create such a table in that database.
NOTE: If you are not familiar with how PostgreSQL's users and grants system works, you might find useful reading the recommended links in the "References" section at the bottom.
A typical installation normally consists of a self-contained database for Fluent Bit in which you can store the output of one or more pipelines. Ultimately, it is your choice to to store them in the same table, or in separate tables, or even in separate databases based on several factors, including workload, scalability, data protection and security.
In this example, for the sake of simplicity, we use a single table called fluentbit in a database called fluentbit that is owned by the user fluentbit. Feel free to use different names. Preferably, for security reasons, do not use the postgres user (which has SUPERUSER privileges).
fluentbit userGenerate a robust random password (e.g. pwgen 20 1) and store it safely. Then, as postgres system user on the server where PostgreSQL is installed, execute:
At the prompt, please provide the password that you previously generated.
As a result, the user fluentbit without superuser privileges will be created.
If you prefer, instead of the createuser application, you can directly use the SQL command .
fluentbit databaseAs postgres system user, please run:
This will create a database called fluentbit owned by the fluentbit user. As a result, the fluentbit user will be able to safely create the data table.
In your main configuration file add the following section:
The output plugin automatically creates a table with the name specified by the table configuration option and made up of the following fields:
tag TEXT
time TIMESTAMP WITHOUT TIMEZONE
data JSONB
As you can see, the timestamp does not contain any information about the time zone and it is therefore referred to the time zone used by the connection to PostgreSQL (timezone setting).
PostgreSQL 10 introduces support for declarative partitioning. In order to improve vertical scalability of the database, you can decide to partition your tables on time ranges (for example on a monthly basis). PostgreSQL supports also subpartitions, allowing you to even partition by hash your records (version 11+), and default partitions (version 11+).
If you are starting now, our recommendation at the moment is to choose the latest major version of PostgreSQL.
PostgreSQL is a really powerful and extensible database engine. More expert users can indeed take advantage of BEFORE INSERT triggers on the main table and re-route records on normalised tables, depending on tags and content of the actual JSON objects.
For example, you can use Fluent Bit to send HTTP log records to the landing table defined in the configuration file. This table contains a BEFORE INSERT trigger (a function in plpgsql language) that normalises the content of the JSON object and that inserts the record in another table (with its own structure and partitioning model). This kind of triggers allow you to discard the record from the landing table by returning NULL.
Here follows a list of useful resources from the PostgreSQL documentation:
Stackdriver output plugin allows to ingest your records into service.
Before to get started with the plugin configuration, make sure to obtain the proper credentials to get access to the service. We strongly recommend to use a common JSON credentials file, reference link:
Your goal is to obtain a credentials JSON file that will be used later by Fluent Bit Stackdriver output plugin.
| Key | Description | default |
|---|
If you are using a Google Cloud Credentials File, the following configuration is enough to get started:
Example configuration file for k8s resource type:
local_resource_id is used by stackdriver output plugin to set the labels field for different k8s resource types. Stackdriver plugin will try to find the local_resource_id field in the log entry. If there is no field logging.googleapis.com/local_resource_id in the log, the plugin will then construct it by using the tag value of the log.
The local_resource_id should be in format:
k8s_container.<namespace_name>.<pod_name>.<container_name>
k8s_node.<node_name>
k8s_pod.<namespace_name>.<pod_name>
This implies that if there is no local_resource_id in the log entry then the tag of logs should match this format. Note that we have an option tag_prefix so it is not mandatory to use k8s_container(node/pod) as the prefix for tag.
Currently, there are four ways which fluent-bit uses to assign fields into the resource/labels section.
Resource Labels API
Monitored Resource API
Local Resource Id
Credentials / Config Parameters
Note that the project_id resource label will always be set from the service credentials or fetched from the metadata server and cannot be overridden.
The resource_labels configuration parameter offers an alternative API for assigning the resource labels. To use, input a list of comma separated strings specifying resource labels plaintext assignments (new=value), mappings from an original field in the log entry to a destination field (destination=$original) and/or environment variable assignments (new=${var}).
For instance, consider the following log entry:
Combined with the following Stackdriver configuration:
This will produce the following log:
This makes the resource_labels API the recommended choice for supporting new or existing resource types that have all resource labels known before runtime or available on the payload during runtime.
An upstream connection error means Fluent Bit was not able to reach Google services, the error looks like this:
This belongs to a network issue by the environment where Fluent Bit is running, make sure that from the Host, Container or Pod you can reach the following Google end-points:
The error looks like this:
Do following check:
If the log entry does not contain the local_resource_id field, does the tag of the log match for format?
If tag_prefix is configured, does the prefix of tag specified in the input plugin match the tag_prefix?
Other implementations
The Syslog output plugin allows you to deliver messages to Syslog servers. It supports RFC3164 and RFC5424 formats through different transports such as UDP, TCP or TLS.
As of Fluent Bit v1.5.3 the configuration is very strict. You must be aware of the structure of your original record so you can configure the plugin to use specific keys to compose your outgoing Syslog message.
Future versions of Fluent Bit are expanding this plugin feature set to support better handling of keys and message composing.
| Key | Description | Default |
|---|
Get started quickly with this configuration file:
The following is an example of how to configure the syslog_sd_key to send Structured Data to the remote Syslog server.
Example log:
Example configuration file:
Example output:
The td output plugin, allows to flush your records into the cloud service.
The plugin supports the following configuration parameters:
| Key | Description | Default |
|---|
In order to start inserting records into , you can run the plugin from the command line or through the configuration file:
Ideally you don't want to expose your API key from the command line, using a configuration file is highly desired.
In your main configuration file append the following Input & Output sections:
The websocket output plugin allows to flush your records into a WebSocket endpoint. For now the functionality is pretty basic and it issues a HTTP GET request to do the handshake, and then use TCP connections to send the data records in either JSON or (or JSON) format.
| Key | Description | default |
|---|
In order to insert records into a HTTP server, you can run the plugin from the command line or through the configuration file:
The websocket plugin, can read the parameters from the command line in two ways, through the -p argument (property) or setting them directly through the service URI. The URI format is the following:
Using the format specified, you could start Fluent Bit through:
In your main configuration file, append the following Input & Output sections:
Once Fluent Bit is running, you can send some messages using the netcat:
From the output of fluent-bit log, we see that once data has been ingested into fluent bit, plugin would perform handshake. After a while, no data or traffic is undergoing, tcp connection would been abort. And then another piece of data arrived, a retry for websocket plugin has been triggered, with another handshake and data flush.
There is another scenario, once websocket server flaps in a short time, which means it goes down and up in a short time, fluent-bit would resume tcp connection immediately. But in that case, websocket output plugin is a malfunction state, it needs to restart fluent-bit to get back to work.
The stdout output plugin allows to print to the standard output the data received through the input plugin. Their usage is very simple as follows:
| Key | Description | default |
|---|
We have specified to gather usage metrics and print them out to the standard output in a human readable way:
No more, no less, it just works.
Send logs to Splunk HTTP Event Collector
Splunk output plugin allows to ingest your records into a service through the HTTP Event Collector (HEC) interface.
To get more details about how to setup the HEC in Splunk please refer to the following documentation:
Connectivity, transport and authentication configuration properties:
| Key | Description | default |
|---|
Content and Splunk metadata (fields) handling configuration properties:
| Key | Description | default |
|---|
In order to insert records into a Splunk service, you can run the plugin from the command line or through the configuration file:
The splunk plugin, can read the parameters from the command line in two ways, through the -p argument (property), e.g:
In your main configuration file append the following Input & Output sections:
By default, the Splunk output plugin nests the record under the event key in the payload sent to the HEC. It will also append the time of the record to a top level time key.
If you would like to customize any of the Splunk event metadata, such as the host or target index, you can set Splunk_Send_Raw On in the plugin configuration, and add the metadata as keys/values in the record. Note: with Splunk_Send_Raw enabled, you are responsible for creating and populating the event section of the payload.
For example, to add a custom index and hostname:
This will create a payload that looks like:
If the option splunk_send_raw has been enabled, the user must take care to put all log details in the event field, and only specify fields known to Splunk in the top level event, if there is a mismatch, Splunk will return a HTTP error 400.
Consider the following example:
splunk_send_raw off
splunk_send_raw on
For up to date information about the valid keys in the top level object, refer to the Splunk documentation:
Sending to a Splunk Metric index requires the use of Splunk_send_raw option being enabled and formatting the message properly. This includes three specific operations
Nest metric events under a "fields" property
Add metric_name: to all metrics
Add index, source, sourcetype as fields in the message
The following configuration gathers CPU metrics, nests the appropriate field, adds the required identifiers and then sends to Splunk.
With Fluent Bit 2.0, you can also send Fluent Bit's metrics type of events into Splunk via Splunk HEC. This allows you to perform visualizations, metric queries, and analysis with directly sent Fluent Bit's metrics type of events. This is based off Splunk 8.0 support of multi metric support via single concatenated JSON payload.
Sending Fluent Bit's metrics into Splunk requires the use of collecting Fluent Bit's metrics plugins. Note that whether events type of logs or metrics can be distinguished automatically. You don't need to pay attentions about the type of events. This example includes two specific operations
Collect node or Fluent Bit's internal metrics
Send metrics as single concatenated JSON payload
The tcp output plugin allows to send records to a remote TCP server. The payload can be formatted in different ways as required.
| Key | Description | default |
|---|
The following parameters are available to configure a secure channel connection through TLS:
| Key | Description | Default |
|---|
Run the following in a separate terminal, netcat will start listening for messages on TCP port 5170. Once it connects to Fluent Bit ou should see the output as above in JSON format:
Repeat the JSON approach but using the msgpack output format.
Send logs to Elasticsearch (including Amazon OpenSearch Service)
The es output plugin, allows to ingest your records into an database. The following instructions assumes that you have a fully operational Elasticsearch service running in your environment.
| Key | Description | default |
|---|
The write_operation can be any of:
Please note, Id_Key or Generate_ID is required in update, and upsert scenario.
In order to insert records into a Elasticsearch service, you can run the plugin from the command line or through the configuration file:
The es plugin, can read the parameters from the command line in two ways, through the -p argument (property) or setting them directly through the service URI. The URI format is the following:
Using the format specified, you could start Fluent Bit through:
which is similar to do:
Some input plugins may generate messages where the field names contains dots, since Elasticsearch 2.0 this is not longer allowed, so the current es plugin replaces them with an underscore, e.g:
becomes
Since Elasticsearch 6.0, you cannot create multiple types in a single index. This means that you cannot set up your configuration as below anymore.
If you see an error message like below, you'll need to fix your configuration to use a single type on each index.
Rejecting mapping update to [search] as the final mapping would have more than 1 type
The Amazon OpenSearch Service adds an extra security layer where HTTP requests must be signed with AWS Sigv4. Fluent Bit v1.5 introduced full support for Amazon OpenSearch Service with IAM Authentication.
Example configuration:
Notice that the Port is set to 443, tls is enabled, and AWS_Region is set.
Example configuration:
Since v1.8.2, Fluent Bit started using create method (instead of index) for data submission. This makes Fluent Bit compatible with Datastream introduced in Elasticsearch 7.9.
If you see action_request_validation_exception errors on your pipeline with Fluent Bit >= v1.8.2, you can fix it up by turning on Generate_ID as follows:
Elastic Cloud is now on version 8 so the type option must be removed by setting Suppress_Type_Name On as indicated above.
Without this you will see errors like:
Required - Your .
Optional - Specify an HTTP Proxy. The expected format of this value is . Note that https is not supported yet.
Optional - The you want to assign to your logs in Datadog.
If Forward will connect to an Upstream instead of a simple host, this property defines the absolute path for the Upstream configuration file, for more details about this refer to the documentation section.
Set to "gzip" to enable gzip compression. Incompatible with Time_as_Integer=True and tags set dynamically using the filter. (Requires Fluentd v0.14.7+ server)
Key to be used as the log level. Its value must be in (between 0 and 7). (Optional in GELF)
Specify an HTTP Proxy. The expected format of this value is http://HOST:PORT. Note that HTTPS is not currently supported. It is recommended not to set this and to configure the instead as they support both HTTP and HTTPS.
for S3 objects.
Specify the for S3 objects. If this option is not specified, objects will be stored with the default 'STANDARD' storage class.
| Operation | Description |
|---|---|
With hosted metrics you will need to use the specific host that is mentioned as well as specify the HTTP username and password given within the Grafana Cloud page.
With Logz.io you will need to make use of the header option and add the Authorization Bearer with the proper key. The host and port may also differ within your specific hosted instance.
With you may need to customize the URI. Additionally, you will make use of the header key with Coralogix private key.
Alternatively, you can use the SQL command .
Make sure that the fluentbit user can connect to the fluentbit database on the specified target host. This might require you to properly configure the file.
| Key | Description | Default |
|---|
Fluent Bit relies on , the PostgreSQL native client API, written in C language. For this reason, default values might be affected by and compilation settings. The above table, in brackets, list the most common default values for each connection option.
For security reasons, it is advised to follow the directives included in the section.
For more information on the JSONB data type in PostgreSQL, please refer to the page in the official documentation, where you can find instructions on how to index or query the objects (including jsonpath introduced in PostgreSQL 12).
For more information on horizontal partitioning in PostgreSQL, please refer to the page in the official documentation.
If resource_labels is correctly configured, then fluent-bit will attempt to populate all resource/labels using the entries specified. Otherwise, fluent-bit will attempt to use the monitored resource API. Similarly, if the monitored resource API cannot be used, then fluent-bit will attempt to populate resource/labels using configuration parameters and/or credentials specific to the resource type. As mentioned in the section, fluent-bit will attempt to use or construct a local resource ID for a K8s resource type which does not use the resource labels or monitored resource API.
For instance, for a K8s resource type, resource_labels can be used in tandem with the to pack all six resource labels. Below is an example of what this could look like for a k8s_container resource:
resource_labels also supports validation for required labels based on the input resource type. This allows fluent-bit to check if all specified labels are present for a given configuration before runtime. If validation is not currently supported for a resource type that you would like to use this API with, we encourage you to open a pull request for it. Adding validation for a new resource type is simple - all that is needed is to specify the resources associated with the type alongside the required labels .
Github reference:
Stackdriver officially supports a .
We plan to support some . Use cases of special fields is .
Websocket plugin is working with tcp keepalive mode, please refer to section for details. Since websocket is a stateful plugin, it will decide when to send out handshake to server side, for example when plugin just begins to work or after connection with server has been dropped. In general, the interval to init a new websocket handshake would be less than the keepalive interval. With that strategy, it could detect and resume websocket connections.
In we should see the following output:
Splunk output plugin supports TTL/SSL, for more details about the properties available and general configuration, please refer to the section.
For more information on the Splunk HEC payload format and all event meatadata Splunk accepts, see here:
With Splunk version 8.0> you can also use the Fluent Bit Splunk output plugin to send data to metric indices. This allows you to perform visualizations, metric queries, and analysis with other metrics you may be collecting. This is based off of Splunk 8.0 support of multi metric support via single JSON payload, more details can be found on
We have specified to gather usage metrics and send them in JSON lines mode to a remote end-point using netcat service.
We could send this to stdout but as it is a serialized format you would end up with strange output. This should really be handled by a msgpack receiver to unpack as per the details in the developer documentation . As an example we use the to deal with it:
The parameters index and type can be confusing if you are new to Elastic, if you have used a common relational database before, they can be compared to the database and table concepts. Also see
Elasticsearch output plugin supports TTL/SSL, for more details about the properties available and general configuration, please refer to the section.
| Operation | Description |
|---|
In your main configuration file append the following Input & Output sections. You can visualize this configuration
For details, please read .
Fluent Bit v1.5 changed the default mapping type from flb_type to _doc, which matches the recommendation from Elasticsearch from version 6.2 forwards (). This doesn't work in Elasticsearch versions 5.6 through 6.1 (). Ensure you set an explicit map (such as doc or flb_type) in the configuration, as seen on the last line:
See for details on how AWS credentials are fetched.
Fluent Bit supports connecting to providing just the cloud_id and the cloud_auth settings. cloud_auth uses the elastic user and password provided when the cluster was created, for details refer to the .
base_uri
Full address of New Relic API end-point. By default the value points to the US end-point.
If you want to use the EU end-point you can set this key to the following value: https://log-api.eu.newrelic.com/log/v1
api_key
Your key for data ingestion. The API key is also called the ingestion key, you can get more details on how to generated in the official documentation here.
From a configuration perspective either an api_key or an license_key is required. New Relic suggest to use primary the api_key.
license_key
Optional authentication parameter for data ingestion.
Note that New Relic suggest to use the api_key instead. You can read more about the License Key here.
compress
Set the compression mechanism for the payload. This option allows two values: gzip (enabled by default) or false to disable compression.
gzip
host
IP address or hostname of Observe's data collection endpoint. $(OBSERVE_CUSTOMER) is your Customer ID
OBSERVE_CUSTOMER.collect.observeinc.com
port
TCP port of to employ when sending to Observe
443
tls
Specify to use tls
on
uri
Specify the HTTP URI for the Observe's data ingest
/v1/http/fluentbit
format
The data format to be used in the HTTP request body
msgpack
header
The specific header that provides the Observe token needed to authorize sending data into a datastream.
Authorization Bearer ${OBSERVE_TOKEN}
header
The specific header to instructs Observe how to decode incoming payloads
X-Observe-Decoder fluent
compress
Set payload compression mechanism. Option available is 'gzip'
gzip
tls.ca_file
For use with Windows: provide path to root cert
format
Specify data format, options available: json, msgpack.
json
message_key
Optional key to store the message
message_key_field
If set, the value of Message_Key_Field in the record will indicate the message key. If not set nor found in the record, Message_Key will be used (if set).
timestamp_key
Set the key to store the record timestamp
@timestamp
timestamp_format
'iso8601' or 'double'
double
brokers
Single of multiple list of Kafka Brokers, e.g: 192.168.1.3:9092, 192.168.1.4:9092.
topics
Single entry or list of topics separated by comma (,) that Fluent Bit will use to send messages to Kafka. If only one topic is set, that one will be used for all records. Instead if multiple topics exists, the one set in the record by Topic_Key will be used.
fluent-bit
topic_key
If multiple Topics exists, the value of Topic_Key in the record will indicate the topic to use. E.g: if Topic_Key is router and the record is {"key1": 123, "router": "route_2"}, Fluent Bit will use topic route_2. Note that if the value of Topic_Key is not present in Topics, then by default the first topic in the Topics list will indicate the topic to be used.
dynamic_topic
adds unknown topics (found in Topic_Key) to Topics. So in Topics only a default topic needs to be configured
Off
queue_full_retries
Fluent Bit queues data into rdkafka library, if for some reason the underlying library cannot flush the records the queue might fills up blocking new addition of records. The queue_full_retries option set the number of local retries to enqueue the data. The default value is 10 times, the interval between each retry is 1 second. Setting the queue_full_retries value to 0 set's an unlimited number of retries.
10
rdkafka.{property}
{property} can be any librdkafka properties
Host
IP address or hostname of the target OpenSearch instance
127.0.0.1
Port
TCP port of the target OpenSearch instance
9200
Path
OpenSearch accepts new data on HTTP query path "/_bulk". But it is also possible to serve OpenSearch behind a reverse proxy on a subpath. This option defines such path on the fluent-bit side. It simply adds a path prefix in the indexing HTTP POST URI.
Empty string
Buffer_Size
Specify the buffer size used to read the response from the OpenSearch HTTP service. This option is useful for debugging purposes where is required to read full responses, note that response size grows depending of the number of records inserted. To set an unlimited amount of memory set this value to False, otherwise the value must be according to the Unit Size specification.
4KB
Pipeline
OpenSearch allows to setup filters called pipelines. This option allows to define which pipeline the database should use. For performance reasons is strongly suggested to do parsing and filtering on Fluent Bit side, avoid pipelines.
AWS_Auth
Enable AWS Sigv4 Authentication for Amazon OpenSearch Service
Off
AWS_Region
Specify the AWS region for Amazon OpenSearch Service
AWS_STS_Endpoint
Specify the custom sts endpoint to be used with STS API for Amazon OpenSearch Service
AWS_Role_ARN
AWS IAM Role to assume to put records to your Amazon cluster
AWS_External_ID
External ID for the AWS IAM Role specified with aws_role_arn
AWS_Service_Name
Service name to be used in AWS Sigv4 signature. For integration with Amazon OpenSearch Serverless, set to aoss. See the FAQ section on Amazon OpenSearch Serverless for more information.
es
HTTP_User
Optional username credential for access
HTTP_Passwd
Password for user defined in HTTP_User
Index
Index name, supports Record Accessor syntax from 2.0.5 onwards.
fluent-bit
Type
Type name. This option is ignored if Suppress_Type_Name is enabled.
_doc
Logstash_Format
Enable Logstash format compatibility. This option takes a boolean value: True/False, On/Off
Off
Logstash_Prefix
When Logstash_Format is enabled, the Index name is composed using a prefix and the date, e.g: If Logstash_Prefix is equals to 'mydata' your index will become 'mydata-YYYY.MM.DD'. The last string appended belongs to the date when the data is being generated.
logstash
Logstash_DateFormat
Time format (based on strftime) to generate the second part of the Index name.
%Y.%m.%d
Time_Key
When Logstash_Format is enabled, each record will get a new timestamp field. The Time_Key property defines the name of that field.
@timestamp
Time_Key_Format
When Logstash_Format is enabled, this property defines the format of the timestamp.
%Y-%m-%dT%H:%M:%S
Time_Key_Nanos
When Logstash_Format is enabled, enabling this property sends nanosecond precision timestamps.
Off
Include_Tag_Key
When enabled, it append the Tag name to the record.
Off
Tag_Key
When Include_Tag_Key is enabled, this property defines the key name for the tag.
_flb-key
Generate_ID
When enabled, generate _id for outgoing records. This prevents duplicate records when retrying.
Off
Id_Key
If set, _id will be the value of the key from incoming record and Generate_ID option is ignored.
Write_Operation
Operation to use to write in bulk requests.
create
Replace_Dots
When enabled, replace field name dots with underscore.
Off
Trace_Output
When enabled print the OpenSearch API calls to stdout (for diag only)
Off
Trace_Error
When enabled print the OpenSearch API calls to stdout when OpenSearch returns an error (for diag only)
Off
Current_Time_Index
Use current time for index generation instead of message record
Off
Logstash_Prefix_Key
When included: the value in the record that belongs to the key will be looked up and over-write the Logstash_Prefix for index generation. If the key/value is not found in the record then the Logstash_Prefix option will act as a fallback. Nested keys are not supported (if desired, you can use the nest filter plugin to remove nesting)
Suppress_Type_Name
When enabled, mapping types is removed and Type option is ignored.
Off
Workers
Enables dedicated thread(s) for this output. Default value is set since version 1.8.13. For previous versions is 0.
2
create (default)
adds new data - if the data already exists (based on its id), the op is skipped.
index
new data is added while existing data (based on its id) is replaced (reindexed).
update
updates existing data (based on its id). If no data is found, the op is skipped.
upsert
known as merge or insert if the data does not exist, updates if the data exists (based on its id).
host
IP address or hostname of the target HTTP Server
127.0.0.1
http_user
Basic Auth Username
http_passwd
Basic Auth Password. Requires HTTP_user to be set
port
TCP port of the target HTTP Server
80
proxy
Specify an HTTP Proxy. The expected format of this value is http://HOST:PORT. Note that HTTPS is not currently supported. It is recommended not to set this and to configure the HTTP proxy environment variables instead as they support both HTTP and HTTPS.
metrics_uri
Specify an optional HTTP URI for the target web server listening for metrics, e.g: /v1/metrics
/
logs_uri
Specify an optional HTTP URI for the target web server listening for logs, e.g: /v1/logs
/
traces_uri
Specify an optional HTTP URI for the target web server listening for traces, e.g: /v1/traces
/
header
Add a HTTP header key/value pair. Multiple headers can be set.
log_response_payload
Log the response payload within the Fluent Bit log
false
add_label
This allows you to add custom labels to all metrics exposed through the OpenTelemetry exporter. You may have multiple of these fields
compress
Set payload compression mechanism. Option available is 'gzip'
Host
IP address or hostname of the target InfluxDB service
127.0.0.1
Port
TCP port of the target InfluxDB service
8086
Database
InfluxDB database name where records will be inserted
fluentbit
Bucket
InfluxDB bucket name where records will be inserted - if specified, database is ignored and v2 of API is used
Org
InfluxDB organization name where the bucket is (v2 only)
fluent
Sequence_Tag
The name of the tag whose value is incremented for the consecutive simultaneous events.
_seq
HTTP_User
Optional username for HTTP Basic Authentication
HTTP_Passwd
Password for user defined in HTTP_User
HTTP_Token
Authentication token used with InfluDB v2 - if specified, both HTTP_User and HTTP_Passwd are ignored
Tag_Keys
Space separated list of keys that needs to be tagged
Auto_Tags
Automatically tag keys where value is string. This option takes a boolean value: True/False, On/Off.
Off
Tags_List_Enabled
Dynamically tag keys which are in the string array at Tags_List_Key key. This option takes a boolean value: True/False, On/Off.
Off
Tags_List_Key
Key of the string array optionally contained within each log record that contains tag keys for that record
tags
host
Loki hostname or IP address. Do not include the subpath, i.e. loki/api/v1/push, but just the base hostname/URL.
127.0.0.1
port
Loki TCP port
3100
http_user
Set HTTP basic authentication user name
http_passwd
Set HTTP basic authentication password
bearer_token
Set bearer token authentication token value.
tenant_id
Tenant ID used by default to push logs to Loki. If omitted or empty it assumes Loki is running in single-tenant mode and no X-Scope-OrgID header is sent.
labels
Stream labels for API request. It can be multiple comma separated of strings specifying key=value pairs. In addition to fixed parameters, it also allows to add custom record keys (similar to label_keys property). More details in the Labels section.
job=fluentbit
label_keys
Optional list of record keys that will be placed as stream labels. This configuration property is for records key only. More details in the Labels section.
label_map_path
Specify the label map file path. The file defines how to extract labels from each record. More details in the Labels section.
remove_keys
Optional list of keys to remove.
drop_single_key
If set to true and after extracting labels only a single key remains, the log line sent to Loki will be the value of that key in line_format.
off
line_format
Format to use when flattening the record to a log line. Valid values are json or key_value. If set to json, the log line sent to Loki will be the Fluent Bit record dumped as JSON. If set to key_value, the log line will be each item in the record concatenated together (separated by a single space) in the format.
json
auto_kubernetes_labels
If set to true, it will add all Kubernetes labels to the Stream labels
off
tenant_id_key
Specify the name of the key from the original record that contains the Tenant ID. The value of the key is set as X-Scope-OrgID of HTTP header. It is useful to set Tenant ID dynamically.
| Hostname/IP address of the PostgreSQL instance | - (127.0.0.1) |
| PostgreSQL port | - (5432) |
| PostgreSQL username | - (current user) |
| Password of PostgreSQL username | - |
| Database name to connect to | - (current user) |
| Table name where to store data | - |
| Key in the JSON object containing the record timestamp | date |
| Define if we will use async or sync connections | false |
| Minimum number of connection in async mode | 1 |
| Maximum amount of connections in async mode | 4 |
| Set to | false |
host | Domain or IP address of the remote Syslog server. | 127.0.0.1 |
port | TCP or UDP port of the remote Syslog server. | 514 |
mode | Desired transport type. Available options are | udp |
syslog_format | The Syslog protocol format to use. Available options are | rfc5424 |
syslog_maxsize | The maximum size allowed per message. The value must be an integer representing the number of bytes allowed. If no value is provided, the default size is set depending of the protocol version specified by |
syslog_severity_key | The key name from the original record that contains the Syslog severity number. This configuration is optional. |
syslog_severity_preset | The preset severity number. It will be overwritten if | 6 |
syslog_facility_key | The key name from the original record that contains the Syslog facility number. This configuration is optional. |
syslog_facility_preset | The preset facility number. It will be overwritten if | 1 |
syslog_hostname_key | The key name from the original record that contains the hostname that generated the message. This configuration is optional. |
syslog_hostname_preset | The preset hostname. It will be overwritten if |
syslog_appname_key | The key name from the original record that contains the application name that generated the message. This configuration is optional. |
syslog_appname_preset | The preset application name. It will be overwritten if |
syslog_procid_key | The key name from the original record that contains the Process ID that generated the message. This configuration is optional. |
syslog_procid_preset | The preset process ID. It will be overwritten if |
syslog_msgid_key | The key name from the original record that contains the Message ID associated to the message. This configuration is optional. |
syslog_msgid_preset | The preset message ID. It will be overwritten if |
syslog_sd_key | The key name from the original record that contains the Structured Data (SD) content. This configuration is optional. |
syslog_message_key | The key name from the original record that contains the message to deliver. Note that this property is mandatory, otherwise the message will be empty. |
Host | Target host where Fluent-Bit or Fluentd are listening for Forward messages. | 127.0.0.1 |
Port | TCP Port of the target service. | 5170 |
Format | Specify the data format to be printed. Supported formats are msgpack json, json_lines and json_stream. | msgpack |
json_date_key | Specify the name of the time key in the output record. To disable the time key just set the value to | date |
json_date_format | Specify the format of the date. Supported formats are double, epoch, iso8601 (eg: 2018-05-30T09:39:52.000681Z) and java_sql_timestamp (eg: 2018-05-30 09:39:52.000681) | double |
Workers | Enables dedicated thread(s) for this output. Default value is set since version 1.8.13. For previous versions is 0. | 2 |
tls | Enable or disable TLS support | Off |
tls.verify | Force certificate validation | On |
tls.debug | Set TLS debug verbosity level. It accept the following values: 0 (No debug), 1 (Error), 2 (State change), 3 (Informational) and 4 Verbose | 1 |
tls.ca_file | Absolute path to CA certificate file |
tls.crt_file | Absolute path to Certificate file. |
tls.key_file | Absolute path to private Key file. |
tls.key_passwd | Optional password for tls.key_file file. |
create (default) | adds new data - if the data already exists (based on its id), the op is skipped. |
index | new data is added while existing data (based on its id) is replaced (reindexed). |
update | updates existing data (based on its id). If no data is found, the op is skipped. |
upsert | known as merge or insert if the data does not exist, updates if the data exists (based on its id). |
host | This is address Fluent Bit will bind to when hosting prometheus metrics. Note: | 0.0.0.0 |
port | This is the port Fluent Bit will bind to when hosting prometheus metrics | 2021 |
add_label | This allows you to add custom labels to all metrics exposed through the prometheus exporter. You may have multiple of these fields |
Host | IP address or hostname of the target WebScoket Server | 127.0.0.1 |
Port | TCP port of the target WebScoket Server | 80 |
URI | Specify an optional HTTP URI for the target websocket server, e.g: /something | / |
Format | Specify the data format to be used in the HTTP request body, by default it uses msgpack. Other supported formats are json, json_stream and json_lines and gelf. | msgpack |
json_date_key | Specify the name of the date field in output | date |
json_date_format | Specify the format of the date. Supported formats are double, epoch, iso8601 (eg: 2018-05-30T09:39:52.000681Z) and java_sql_timestamp (eg: 2018-05-30 09:39:52.000681) | double |
host | IP address or hostname of the target Splunk service. | 127.0.0.1 |
port | TCP port of the target Splunk service. | 8088 |
splunk_token | Specify the Authentication Token for the HTTP Event Collector interface. |
http_user | Optional username for Basic Authentication on HEC |
http_passwd | Password for user defined in HTTP_User |
http_buffer_size | Buffer size used to receive Splunk HTTP responses | 2M |
compress | Set payload compression mechanism. The only available option is |
channel | Specify X-Splunk-Request-Channel Header for the HTTP Event Collector interface. |
http_debug_bad_request | If the HTTP server response code is 400 (bad request) and this flag is enabled, it will print the full HTTP request and response to the stdout interface. This feature is available for debugging purposes. |
Workers | Enables dedicated thread(s) for this output. Default value is set since version 1.8.13. For previous versions is 0. | 2 |
splunk_send_raw | When enabled, the record keys and values are set in the top level of the map instead of under the event key. Refer to the Sending Raw Events section from the docs for more details to make this option work properly. | off |
event_key | Specify the key name that will be used to send a single value as part of the record. |
event_host | Specify the key name that contains the host value. This option allows a record accessors pattern. |
event_source | Set the source value to assign to the event data. |
event_sourcetype | Set the sourcetype value to assign to the event data. |
event_sourcetype_key | Set a record key that will populate 'sourcetype'. If the key is found, it will have precedence over the value set in |
event_index | The name of the index by which the event data is to be indexed. |
event_index_key | Set a record key that will populate the |
event_field | Set event fields for the record. This option can be set multiple times and the format is |
Format | Specify the data format to be printed. Supported formats are msgpack json, json_lines and json_stream. | msgpack |
json_date_key | Specify the name of the time key in the output record. To disable the time key just set the value to | date |
json_date_format | Specify the format of the date. Supported formats are double, epoch, iso8601 (eg: 2018-05-30T09:39:52.000681Z) and java_sql_timestamp (eg: 2018-05-30 09:39:52.000681) | double |
Workers | Enables dedicated thread(s) for this output. Default value is set since version 1.8.13. For previous versions is 0. | 1 |
host | IP address or hostname of the target HTTP Server | 127.0.0.1 |
http_user | Basic Auth Username |
http_passwd | Basic Auth Password. Requires HTTP_user to be set |
port | TCP port of the target HTTP Server | 80 |
proxy |
uri | Specify an optional HTTP URI for the target web server, e.g: /something | / |
header | Add a HTTP header key/value pair. Multiple headers can be set. |
log_response_payload | Log the response payload within the Fluent Bit log | false |
add_label | This allows you to add custom labels to all metrics exposed through the prometheus exporter. You may have multiple of these fields |
Workers | Enables dedicated thread(s) for this output. Default value is set since version 1.8.13. For previous versions is 0. | 2 |
google_service_credentials | Absolute path to a Google Cloud credentials JSON file | Value of environment variable $GOOGLE_APPLICATION_CREDENTIALS |
service_account_email | Account email associated to the service. Only available if no credentials file has been provided. | Value of environment variable $SERVICE_ACCOUNT_EMAIL |
service_account_secret | Private key content associated with the service account. Only available if no credentials file has been provided. | Value of environment variable $SERVICE_ACCOUNT_SECRET |
metadata_server | Prefix for a metadata server. Can also set environment variable $METADATA_SERVER. |
location | The GCP or AWS region in which to store data about the resource. If the resource type is one of the generic_node or generic_task, then this field is required. |
namespace | A namespace identifier, such as a cluster name or environment. If the resource type is one of the generic_node or generic_task, then this field is required. |
node_id | A unique identifier for the node within the namespace, such as hostname or IP address. If the resource type is generic_node, then this field is required. |
job | An identifier for a grouping of related task, such as the name of a microservice or distributed batch. If the resource type is generic_task, then this field is required. |
task_id | A unique identifier for the task within the namespace and job, such as a replica index identifying the task within the job. If the resource type is generic_task, then this field is required. |
export_to_project_id | The GCP project that should receive these logs. | Defaults to the project ID of the google_service_credentials file, or the project_id from Google's metadata.google.internal server. |
resource | Set resource type of data. Supported resource types: k8s_container, k8s_node, k8s_pod, global, generic_node, generic_task, and gce_instance. | global, gce_instance |
k8s_cluster_name | The name of the cluster that the container (node or pod based on the resource type) is running in. If the resource type is one of the k8s_container, k8s_node or k8s_pod, then this field is required. |
k8s_cluster_location | The physical location of the cluster that contains (node or pod based on the resource type) the container. If the resource type is one of the k8s_container, k8s_node or k8s_pod, then this field is required. |
labels_key | The value of this field is used by the Stackdriver output plugin to find the related labels from jsonPayload and then extract the value of it to set the LogEntry Labels. | logging.googleapis.com/labels |
labels | Optional list of comma separated of strings specifying |
log_name_key | The value of this field is used by the Stackdriver output plugin to extract logName from jsonPayload and set the logName field. | logging.googleapis.com/logName |
tag_prefix | Set the tag_prefix used to validate the tag of logs with k8s resource type. Without this option, the tag of the log must be in format of k8s_container(pod/node).* in order to use the k8s_container resource type. Now the tag prefix is configurable by this option (note the ending dot). | k8s_container., k8s_pod., k8s_node. |
severity_key | Specify the name of the key from the original record that contains the severity information. |
autoformat_stackdriver_trace | Rewrite the trace field to include the projectID and format it for use with Cloud Trace. When this flag is enabled, the user can get the correct result by printing only the traceID (usually 32 characters). | false |
Workers | Enables dedicated thread(s) for this output. Default value is set since version 1.8.13. For previous versions is 0. | 2 |
custom_k8s_regex | Set a custom regex to extract field like pod_name, namespace_name, container_name and docker_id from the local_resource_id in logs. This is helpful if the value of pod or node name contains dots. |
|
resource_labels |
API |
Database | Specify the name of your target database. |
Table | Specify the name of your target table where the records will be stored. |
Region | Set the service region, available values: US and JP | US |
Host | IP address or hostname of the target Elasticsearch instance | 127.0.0.1 |
Port | TCP port of the target Elasticsearch instance | 9200 |
Path | Elasticsearch accepts new data on HTTP query path "/_bulk". But it is also possible to serve Elasticsearch behind a reverse proxy on a subpath. This option defines such path on the fluent-bit side. It simply adds a path prefix in the indexing HTTP POST URI. | Empty string |
compress | Set payload compression mechanism. Option available is 'gzip' |
Buffer_Size | 4KB |
Pipeline | Newer versions of Elasticsearch allows to setup filters called pipelines. This option allows to define which pipeline the database should use. For performance reasons is strongly suggested to do parsing and filtering on Fluent Bit side, avoid pipelines. |
AWS_Auth | Enable AWS Sigv4 Authentication for Amazon OpenSearch Service | Off |
AWS_Region | Specify the AWS region for Amazon OpenSearch Service |
AWS_STS_Endpoint | Specify the custom sts endpoint to be used with STS API for Amazon OpenSearch Service |
AWS_Role_ARN | AWS IAM Role to assume to put records to your Amazon cluster |
AWS_External_ID | External ID for the AWS IAM Role specified with |
AWS_Service_Name | es |
Cloud_ID | If you are using Elastic's Elasticsearch Service you can specify the cloud_id of the cluster running. The Cloud ID string has the format |
Cloud_Auth | Specify the credentials to use to connect to Elastic's Elasticsearch Service running on Elastic Cloud |
HTTP_User | Optional username credential for Elastic X-Pack access |
HTTP_Passwd | Password for user defined in HTTP_User |
Index | Index name | fluent-bit |
Type | Type name | _doc |
Logstash_Format | Enable Logstash format compatibility. This option takes a boolean value: True/False, On/Off | Off |
Logstash_Prefix | When Logstash_Format is enabled, the Index name is composed using a prefix and the date, e.g: If Logstash_Prefix is equals to 'mydata' your index will become 'mydata-YYYY.MM.DD'. The last string appended belongs to the date when the data is being generated. | logstash |
Logstash_DateFormat | %Y.%m.%d |
Time_Key | When Logstash_Format is enabled, each record will get a new timestamp field. The Time_Key property defines the name of that field. | @timestamp |
Time_Key_Format | When Logstash_Format is enabled, this property defines the format of the timestamp. | %Y-%m-%dT%H:%M:%S |
Time_Key_Nanos | When Logstash_Format is enabled, enabling this property sends nanosecond precision timestamps. | Off |
Include_Tag_Key | When enabled, it append the Tag name to the record. | Off |
Tag_Key | When Include_Tag_Key is enabled, this property defines the key name for the tag. | _flb-key |
Generate_ID | When enabled, generate | Off |
Id_Key | If set, |
Write_Operation | The write_operation can be any of: create (default), index, update, upsert. | create |
Replace_Dots | When enabled, replace field name dots with underscore, required by Elasticsearch 2.0-2.3. | Off |
Trace_Output | Print all elasticsearch API request payloads to stdout (for diag only) | Off |
Trace_Error | If elasticsearch return an error, print the elasticsearch API request and response (for diag only) | Off |
Current_Time_Index | Use current time for index generation instead of message record | Off |
Logstash_Prefix_Key | When included: the value in the record that belongs to the key will be looked up and over-write the Logstash_Prefix for index generation. If the key/value is not found in the record then the Logstash_Prefix option will act as a fallback. Nested keys are not supported (if desired, you can use the nest filter plugin to remove nesting) |
Suppress_Type_Name | Off |
Workers | Enables dedicated thread(s) for this output. Default value is set since version 1.8.13. For previous versions is 0. | 2 |
The Slack output plugin delivers records or messages to your preferred Slack channel. It formats the outgoing content in JSON format for readability.
This connector uses the Slack Incoming Webhooks feature to post messages to Slack channels. Using this plugin in conjunction with the Stream Processor is a good combination for alerting.
Before configuring this plugin, make sure to setup your Incoming Webhook. For detailed step-by-step instructions, review the following official documentation:
Once you have obtained the Webhook address you can place it in the configuration below.
| Key | Description | Default |
|---|---|---|
Get started quickly with this configuration file:
Specify an HTTP Proxy. The expected format of this value is http://HOST:PORT. Note that HTTPS is not currently supported. It is recommended not to set this and to configure the instead as they support both HTTP and HTTPS.
An optional list of comma separated strings specifying resource labels plaintext assignments (new=value) and/or mappings from an original field in the log entry to a destination field (destination=$original). Nested fields and environment variables are also supported using the . If configured, all resource labels will be assigned using this API only, with the exception of project_id. See for more details.
The API key. To obtain it please log into the and in the API keys box, copy the API key hash.
Specify the buffer size used to read the response from the Elasticsearch HTTP service. This option is useful for debugging purposes where is required to read full responses, note that response size grows depending of the number of records inserted. To set an unlimited amount of memory set this value to False, otherwise the value must be according to the specification.
Service name to be used in AWS Sigv4 signature. For integration with Amazon OpenSearch Serverless, set to aoss. See the section on Amazon OpenSearch Serverless for more information.
Time format (based on ) to generate the second part of the Index name.
When enabled, mapping types is removed and Type option is ignored. Types are deprecated in APIs in . This options is for v7.0 or later.
webhook
Absolute address of the Webhook provided by Slack
