> ## Documentation Index
> Fetch the complete documentation index at: https://launchdarkly-preview.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Fluent Bit

> This topic explains how to send logs from Fluent Bit to LaunchDarkly's observability dashboards.

> For the complete documentation index, see [llms.txt](/llms.txt). For the full documentation snapshot, see [llms-full.txt](/llms-full.txt).

## Overview

This topic explains how to send logs from [Fluent Bit](https://fluentbit.io/) to LaunchDarkly's observability dashboards. Fluent Bit is a lightweight and high-performance log processor and forwarder that is commonly used in containerized environments such as Kubernetes and Amazon ECS.By configuring Fluent Bit to forward logs to LaunchDarkly, you can centralize your application logs alongside your feature flag data for unified observability.

## Prerequisites

To use the Fluent Bit integration, you need:

* A LaunchDarkly project key for your target environment
* Fluent Bit installed and running in your environment
* Network access to LaunchDarkly's OpenTelemetry endpointTo learn how to find and copy your LaunchDarkly project key, read [Project keys](/home/account/project#project-keys).

## Configure Fluent Bit

Fluent Bit uses the [Forward protocol](https://docs.fluentbit.io/manual/pipeline/outputs/forward) to send logs to LaunchDarkly's OpenTelemetry collector endpoint.

### Basic configuration

Add the following output configuration to your Fluent Bit configuration file:

<CodeGroup>
  ```ini title="fluent-bit.conf" theme={null}
      [OUTPUT]
          Name          forward
          Match         *
          Host          otel.observability.app.launchdarkly.com
          Port          24224
          Tag           launchdarkly.project_id=YOUR_PROJECT_KEY
  ```
</CodeGroup>

Replace `YOUR_PROJECT_KEY` with your LaunchDarkly project key.

### Configuration with TLSFor production environments, enable TLS for secure communication:

<CodeGroup>
  ```ini title="fluent-bit.conf" theme={null}
      [OUTPUT]
          Name          forward
          Match         *
          Host          otel.observability.app.launchdarkly.com
          Port          24224
          Tag           launchdarkly.project_id=YOUR_PROJECT_ID
          tls           on
          tls.verify    on
  ```
</CodeGroup>

### AWS ECS with AWS Fire

LensIf you're running containers on Amazon ECS, you can use AWS FireLens to route logs through Fluent Bit to LaunchDarkly. FireLens is a container log router for Amazon ECS that gives you the ability to use Fluent Bit for log processing.

Here's an example ECS task definition snippet:

<CodeGroup>
  ```json title="task-definition.json" theme={null}
      {
        "containerDefinitions": [
          {
            "name": "your-app",
            "image": "your-app-image",
            "logConfiguration": {
              "logDriver": "awsfirelens",
              "options": {
                "Name": "forward",
                "Host": "otel.observability.app.launchdarkly.com",
                "Port": "24224",
                "Tag": "launchdarkly.project_id=YOUR_PROJECT_KEY"
              }
            }
          },
          {
            "name": "log_router",
            "image": "amazon/aws-for-fluent-bit:latest",
            "essential": true,
            "firelensConfiguration": {
              "type": "fluentbit"
            }
          }
        ]
      }
  ```
</CodeGroup>

Here is an example using Terraform:

<CodeGroup>
  ```hcl title="ecs.tf" theme={null}
      resource "aws_ecs_task_definition" "app" {
        # ... other configuration ...

        container_definitions = jsonencode([
          {
            name  = "your-app"
            image = "your-app-image"
            logConfiguration = {
              logDriver = "awsfirelens"
              options = {
                Name = "Forward"
                Host = var.observability_logging.host
                Port = "24224"
                Tag  = "launchdarkly.project_id=${var.launchdarkly_project_id}"
              }
            }
          },
          {
            name      = "log_router"
            image     = "amazon/aws-for-fluent-bit:latest"
            essential = true
            firelensConfiguration = {
              type = "fluentbit"
            }
          }
        ])
      }
  ```
</CodeGroup>

### Kubernetes with Fluent Bit Daemon

SetFor Kubernetes environments, you can configure Fluent Bit as a DaemonSet to collect logs from all pods:

<CodeGroup>
  ```yaml title="fluent-bit-configmap.yaml" theme={null}
      apiVersion: v1
      kind: ConfigMap
      metadata:
        name: fluent-bit-config
        namespace: logging
      data:
        fluent-bit.conf: |
          [SERVICE]
              Flush         1
              Log_Level     info
              Daemon        off
              Parsers_File  parsers.conf

          [INPUT]
              Name              tail
              Path              /var/log/containers/*.log
              Parser            docker
              Tag               kube.*
              Refresh_Interval  5
              Mem_Buf_Limit     5MB

          [OUTPUT]
              Name          forward
              Match         *
              Host          otel.observability.app.launchdarkly.com
              Port          24224
              Tag           launchdarkly.project_id=YOUR_PROJECT_KEY
              tls           on
              tls.verify    on
  ```
</CodeGroup>

## Configuration options

The following table describes the key configuration options for the Fluent Bit Forward output:

\| Option

\| Description

| Required |
| - |

\| ---

\| --- |
\| <code>Host</code>

\| LaunchDarkly's OpenTelemetry endpoint: <code>otel.observability.app.launchdarkly.com</code>

\| Yes |
\| <code>Port</code>

\| The port number: <code>24224</code>

\| Yes |
\| <code>Tag</code>

\| Must include <code>launchdarkly.project\_id=YOUR\_PROJECT\_KEY</code> to route logs to your project

\| Yes |
\| <code>tls</code>

\| Enable TLS encryption. Set to <code>on</code> for production.

\| Recommended |
\| <code>tls.verify</code>

\| Verify TLS certificates. Set to <code>on</code> for production.

\| Recommended |

## View logs in Launch

Darkly observability dashboardsAfter you configure Fluent Bit, logs begin flowing to LaunchDarkly within a few minutes.

To view your logs:

1. Navigate to **Observability** in LaunchDarkly.
2. Select the environment associated with your project.
3. Navigate to the **Logs** tab.
4. Use the search and filter options to find specific log entries.

Your logs are automatically associated with your LaunchDarkly project, allowing you to correlate log data with feature flag evaluations and other observability metrics.

## Troubleshooting

If logs are not appearing in LaunchDarkly:

1. **Verify network connectivity**: Ensure your Fluent Bit instance can reach `otel.observability.app.launchdarkly.com` on port `24224`.

2. **Check the project key**: Verify that the `launchdarkly.project_id` in your tag matches your actual LaunchDarkly project key.

3. **Review Fluent Bit logs**: Check Fluent Bit's own logs for connection errors or warnings:

<CodeGroup>
  ```bash title="Shell" theme={null}
      # For standalone Fluent Bit
      fluent-bit -c /path/to/fluent-bit.conf -v

      # For Kubernetes DaemonSet
      kubectl logs -n logging -l app=fluent-bit
  ```
</CodeGroup>

4. **Test connectivity**: Use a tool like `nc` or `telnet` to verify port accessibility:

<CodeGroup>
  ```bash title="Shell" theme={null}
      nc -zv otel.observability.app.launchdarkly.com 24224
  ```
</CodeGroup>

## Related content

* [Observability overview](/home/observability)
* [Logs](/home/observability/logs)
* [Fluent Bit documentation](https://docs.fluentbit.io/)
* [AWS FireLens documentation](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html)