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

# Fluent Bit

export const host_2 = "otel.observability.app.eu.launchdarkly.com"

export const host_1 = "otel.observability.app.launchdarkly.com"

export const host_0 = "otel.observability.app.launchdarkly.com"

<View title="Developer">
  <View title="Federal docs">
    <Danger>
      **This integration is not available in federal environments**

      To learn more, read <a href="/docs/home/infrastructure/federal">LaunchDarkly in federal environments</a>.
    </Danger>
  </View>

  This topic explains how to send logs from [Fluent Bit](https://fluentbit.io/) to the LaunchDarkly 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 the LaunchDarkly OpenTelemetry endpoint

  To learn how to find and copy your LaunchDarkly project key, read [Project keys](/docs/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 the LaunchDarkly OpenTelemetry collector endpoint.

  ### Basic configuration

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

  <CodeGroup>
    ```ini title="fluent-bit.conf" lines wrap 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 TLS

  For production environments, enable TLS for secure communication:

  <CodeGroup>
    ```ini title="fluent-bit.conf" lines wrap theme={null}
    [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>

  ### AWS ECS with AWS FireLens

  If 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" expandable lines wrap 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" expandable lines wrap 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 DaemonSet

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

  <CodeGroup>
    ```yaml title="fluent-bit-configmap.yaml" expandable lines wrap 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:

  <table>
    <thead>
      <tr>
        <th>Option</th>
        <th>Description</th>
        <th>Required</th>
      </tr>
    </thead>

    <tbody>
      <tr>
        <td><code>Host</code></td>
        <td>The LaunchDarkly OpenTelemetry endpoint: <code>{host_0}</code></td>
        <td>Yes</td>
      </tr>

      <tr>
        <td><code>Port</code></td>
        <td>The port number: <code>24224</code></td>
        <td>Yes</td>
      </tr>

      <tr>
        <td><code>Tag</code></td>
        <td>Must include <code>launchdarkly.project\_id=YOUR\_PROJECT\_KEY</code> to route logs to your project</td>
        <td>Yes</td>
      </tr>

      <tr>
        <td><code>tls</code></td>
        <td>Enable TLS encryption. Set to <code>on</code> for production.</td>
        <td>Recommended</td>
      </tr>

      <tr>
        <td><code>tls.verify</code></td>
        <td>Verify TLS certificates. Set to <code>on</code> for production.</td>
        <td>Recommended</td>
      </tr>
    </tbody>
  </table>

  ## View logs in LaunchDarkly observability dashboards

  After you configure Fluent Bit, logs begin flowing to LaunchDarkly within a few minutes.

  To review 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 <code>{host_0}</code> 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" lines wrap 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" lines wrap theme={null}
    nc -zv otel.observability.app.launchdarkly.com 24224
    ```
  </CodeGroup>

  ## Related content

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

<View title="Federal docs">
  <View title="Federal docs">
    <Danger>
      **This integration is not available in federal environments**

      To learn more, read <a href="/docs/home/infrastructure/federal">LaunchDarkly in federal environments</a>.
    </Danger>
  </View>

  This topic explains how to send logs from [Fluent Bit](https://fluentbit.io/) to the LaunchDarkly 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 the LaunchDarkly OpenTelemetry endpoint

  To learn how to find and copy your LaunchDarkly project key, read [Project keys](/docs/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 the LaunchDarkly OpenTelemetry collector endpoint.

  ### Basic configuration

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

  <CodeGroup>
    ```ini title="fluent-bit.conf" lines wrap 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 TLS

  For production environments, enable TLS for secure communication:

  <CodeGroup>
    ```ini title="fluent-bit.conf" lines wrap theme={null}
    [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>

  ### AWS ECS with AWS FireLens

  If 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" expandable lines wrap 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" expandable lines wrap 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 DaemonSet

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

  <CodeGroup>
    ```yaml title="fluent-bit-configmap.yaml" expandable lines wrap 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:

  <table>
    <thead>
      <tr>
        <th>Option</th>
        <th>Description</th>
        <th>Required</th>
      </tr>
    </thead>

    <tbody>
      <tr>
        <td><code>Host</code></td>
        <td>The LaunchDarkly OpenTelemetry endpoint: <code>{host_1}</code></td>
        <td>Yes</td>
      </tr>

      <tr>
        <td><code>Port</code></td>
        <td>The port number: <code>24224</code></td>
        <td>Yes</td>
      </tr>

      <tr>
        <td><code>Tag</code></td>
        <td>Must include <code>launchdarkly.project\_id=YOUR\_PROJECT\_KEY</code> to route logs to your project</td>
        <td>Yes</td>
      </tr>

      <tr>
        <td><code>tls</code></td>
        <td>Enable TLS encryption. Set to <code>on</code> for production.</td>
        <td>Recommended</td>
      </tr>

      <tr>
        <td><code>tls.verify</code></td>
        <td>Verify TLS certificates. Set to <code>on</code> for production.</td>
        <td>Recommended</td>
      </tr>
    </tbody>
  </table>

  ## View logs in LaunchDarkly observability dashboards

  After you configure Fluent Bit, logs begin flowing to LaunchDarkly within a few minutes.

  To review 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 <code>{host_1}</code> 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" lines wrap 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" lines wrap theme={null}
    nc -zv otel.observability.app.launchdarkly.com 24224
    ```
  </CodeGroup>

  ## Related content

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

<View title="EU docs">
  <View title="Federal docs">
    <Danger>
      **This integration is not available in federal environments**

      To learn more, read <a href="/docs/home/infrastructure/federal">LaunchDarkly in federal environments</a>.
    </Danger>
  </View>

  This topic explains how to send logs from [Fluent Bit](https://fluentbit.io/) to the LaunchDarkly 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 the LaunchDarkly OpenTelemetry endpoint

  To learn how to find and copy your LaunchDarkly project key, read [Project keys](/docs/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 the LaunchDarkly OpenTelemetry collector endpoint.

  ### Basic configuration

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

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

  Replace `YOUR_PROJECT_KEY` with your LaunchDarkly project key.

  ### Configuration with TLS

  For production environments, enable TLS for secure communication:

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

  ### AWS ECS with AWS FireLens

  If 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" expandable lines wrap theme={null}
    {
      "containerDefinitions": [
        {
          "name": "your-app",
          "image": "your-app-image",
          "logConfiguration": {
            "logDriver": "awsfirelens",
            "options": {
              "Name": "forward",
              "Host": "otel.observability.app.eu.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" expandable lines wrap 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 DaemonSet

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

  <CodeGroup>
    ```yaml title="fluent-bit-configmap.yaml" expandable lines wrap 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.eu.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:

  <table>
    <thead>
      <tr>
        <th>Option</th>
        <th>Description</th>
        <th>Required</th>
      </tr>
    </thead>

    <tbody>
      <tr>
        <td><code>Host</code></td>
        <td>The LaunchDarkly OpenTelemetry endpoint: <code>{host_2}</code></td>
        <td>Yes</td>
      </tr>

      <tr>
        <td><code>Port</code></td>
        <td>The port number: <code>24224</code></td>
        <td>Yes</td>
      </tr>

      <tr>
        <td><code>Tag</code></td>
        <td>Must include <code>launchdarkly.project\_id=YOUR\_PROJECT\_KEY</code> to route logs to your project</td>
        <td>Yes</td>
      </tr>

      <tr>
        <td><code>tls</code></td>
        <td>Enable TLS encryption. Set to <code>on</code> for production.</td>
        <td>Recommended</td>
      </tr>

      <tr>
        <td><code>tls.verify</code></td>
        <td>Verify TLS certificates. Set to <code>on</code> for production.</td>
        <td>Recommended</td>
      </tr>
    </tbody>
  </table>

  ## View logs in LaunchDarkly observability dashboards

  After you configure Fluent Bit, logs begin flowing to LaunchDarkly within a few minutes.

  To review 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 <code>{host_2}</code> 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" lines wrap 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" lines wrap theme={null}
    nc -zv otel.observability.app.eu.launchdarkly.com 24224
    ```
  </CodeGroup>

  ## Related content

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