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

# OpenLineage Hybrid Runner

> Connect your data pipelines with Collate's OpenLineage connector. Track data lineage, monitor pipeline metadata, and gain end-to-end visibility.

export const ConnectorDetailsHeader = ({name, icon, stage, availableFeatures, unavailableFeatures = [], availableFeaturesCollate = []}) => {
  const showSubHeading = availableFeatures?.length > 0 || unavailableFeatures?.length > 0 || availableFeaturesCollate?.length > 0;
  const totalAvailableFeatures = [...availableFeatures || [], ...availableFeaturesCollate || []];
  return <div className="container">
      <div className="Heading">
        <div className="flex items-center gap-3">
          {icon && <div className="IconContainer">
              <img src={icon} alt={name} noZoom className="ConnectorIcon" />
            </div>}
          <h1 className="ConnectorName">{name}</h1>
          <span className={`StageBadge ${stage === 'PROD' ? 'prod' : 'beta'}`}>
            {stage}
          </span>
        </div>
      </div>
      {showSubHeading && <div className="SubHeading">
          <div className="FeaturesHeading">Feature List</div>
          <div className="FeaturesList">
            {totalAvailableFeatures.map(feature => <div className="FeatureTag AvailableFeature" key={feature}>
                ✓ {feature}
              </div>)}
            {unavailableFeatures.map(feature => <div className="FeatureTag UnavailableFeature" key={feature}>
                ✕ {feature}
              </div>)}
          </div>
        </div>}
    </div>;
};

<ConnectorDetailsHeader icon="/public/images/connectors/openlineage.png" name="OpenLineage" stage="PROD" availableFeatures={["Pipelines", "Lineage", "Usage"]} unavailableFeatures={["Pipeline Status", "Owners", "Tags"]} />

This section provides guides and references to use the OpenLineage connector.
Configure and schedule OpenLineage metadata workflows from the Collate UI:

* [Requirements](#requirements)
* [Metadata Ingestion](#metadata-ingestion)
* [Troubleshooting](/ai-2-0/connectors/pipeline/openlineage/troubleshooting)

## Requirements

Collate is integrated with OpenLineage up to version 1.37.0 and will continue to work for future OpenLineage versions.
OpenLineage is an open framework for data lineage collection and analysis. At its core is an extensible specification that systems can use to interoperate with lineage metadata.
Apart from being a specification, it is also a set of integrations collecting lineage from various systems such as Apache Airflow and Spark.

### OpenLineage Connector Events

OpenLineage connector consumes OpenLineage events from either a **Kafka broker** or **AWS Kinesis Data Streams** and translates them to Collate lineage information.

### Kafka Configuration

#### Airflow OpenLineage Events (Kafka)

To configure your Airflow instance:

1. Install the appropriate provider in [Airflow](https://airflow.apache.org/docs/apache-airflow-providers-openlineage/stable/index.html).
2. Configure the OpenLineage provider in Airflow.
   * Use `kafka` transport mode because OpenLineage events are collected from the Kafka topic. For detailed configuration options, see the [OpenLineage Python client documentation](https://openlineage.io/docs/client/python/#configuration).

#### Spark OpenLineage Events (Kafka)

Configure your Spark session to produce OpenLineage events compatible with the Collate connector:

```python theme={null}
from pyspark.sql import SparkSession
from uuid import uuid4

spark = SparkSession.builder\
    .config('spark.openlineage.namespace', 'mynamespace')\
    .config('spark.openlineage.parentJobName', 'hello-world')\
    .config('spark.openlineage.parentRunId', str(uuid4()))\
    .config('spark.jars.packages', 'io.openlineage:openlineage-spark_2.12:1.37.0')\
    .config('spark.extraListeners', 'io.openlineage.spark.agent.OpenLineageSparkListener')\
    .config('spark.openlineage.transport.type', 'kafka')\
    .getOrCreate()
```

### AWS Kinesis Configuration

The OpenLineage connector also supports consuming events from AWS Kinesis Data Streams. This is useful when your data pipelines publish OpenLineage events to Kinesis instead of Kafka.

#### Kinesis Requirements

* An AWS Kinesis Data Stream receiving OpenLineage events
* AWS credentials with permissions to read from the Kinesis stream:
  * `kinesis:GetRecords`
  * `kinesis:GetShardIterator`
  * `kinesis:DescribeStream`
  * `kinesis:ListShards`

#### Spark OpenLineage Events (Kinesis)

Configure your Spark session to produce OpenLineage events to Kinesis:

```python theme={null}
from pyspark.sql import SparkSession
from uuid import uuid4

spark = SparkSession.builder\
    .config('spark.openlineage.namespace', 'mynamespace')\
    .config('spark.openlineage.parentJobName', 'hello-world')\
    .config('spark.openlineage.parentRunId', str(uuid4()))\
    .config('spark.jars.packages', 'io.openlineage:openlineage-spark_2.12:1.37.0')\
    .config('spark.extraListeners', 'io.openlineage.spark.agent.OpenLineageSparkListener')\
    .config('spark.openlineage.transport.type', 'kinesis')\
    .config('spark.openlineage.transport.streamName', 'openlineage-events')\
    .config('spark.openlineage.transport.region', 'us-east-2')\
    .getOrCreate()
```

## Metadata Ingestion

To ingest metadata from OpenLineage, you need to create a service connection. The service connects OpenLineage with Collate. Once you create a service, Collate automatically starts ingesting metadata.

### Step 1: Add New Service

1. In the left navigation, click **Connections**.
2. On the **Connections** page, click **Add New Service**.

<img src="https://mintcdn.com/collatedocs/bv5oe4uRjuorTJO1/public/images/ai-2.0/connectors/metadata-ingestion/add-new-service.png?fit=max&auto=format&n=bv5oe4uRjuorTJO1&q=85&s=733cef1141ef13d318634aa9f407eb2b" alt="Add New Service" width="2992" height="1256" data-path="public/images/ai-2.0/connectors/metadata-ingestion/add-new-service.png" />

### Step 2: Select a Service and Connector

From the service type dropdown, select **Pipeline Services**, then click the **OpenLineage** connector tile.

<img src="https://mintcdn.com/collatedocs/tVR0kaoXvgs3p2Wx/public/images/ai-2.0/connectors/metadata-ingestion/Pipeline/select-service/openlineage.png?fit=max&auto=format&n=tVR0kaoXvgs3p2Wx&q=85&s=877ec3599cb34e687d72f6c3ce978d1d" alt="Select Service" width="2102" height="1536" data-path="public/images/ai-2.0/connectors/metadata-ingestion/Pipeline/select-service/openlineage.png" />

### Step 3: Add Service Name and Description

* Enter a unique, descriptive **Service Name**. Collate identifies services by their service name. Enter a name that distinguishes this deployment from other OpenLineage services you are ingesting metadata from.
* Optional: Enter a **Description** for the service.

<img src="https://mintcdn.com/collatedocs/bv5oe4uRjuorTJO1/public/images/ai-2.0/connectors/metadata-ingestion/Pipeline/service-name/openlineage.png?fit=max&auto=format&n=bv5oe4uRjuorTJO1&q=85&s=971354994aff0ba8114ced5b4ad4cfd3" alt="Add New Service Name" width="1458" height="818" data-path="public/images/ai-2.0/connectors/metadata-ingestion/Pipeline/service-name/openlineage.png" />

<Note>
  **Note**: The service name cannot be changed after it is set.
</Note>

### Step 4: Configure Connection Options

Specify where ingestion runs, provide your source credentials, and verify the connection.

#### Select Ingestion Runner

Select an **Ingestion Runner**: the runner where the ingestion pipeline will execute.

<img src="https://mintcdn.com/collatedocs/bv5oe4uRjuorTJO1/public/images/ai-2.0/connectors/metadata-ingestion/select-ingestion-runner.png?fit=max&auto=format&n=bv5oe4uRjuorTJO1&q=85&s=1249f828648614445e8a976ea1933487" alt="Add Name and Select Ingestion Runner" width="1444" height="506" data-path="public/images/ai-2.0/connectors/metadata-ingestion/select-ingestion-runner.png" />

#### Enter Connection Details

Enter the connection details for OpenLineage. The right-hand panel in the UI displays inline help for each field.

<img src="https://mintcdn.com/collatedocs/tVR0kaoXvgs3p2Wx/public/images/ai-2.0/connectors/metadata-ingestion/Pipeline/connection-details/openlineage.png?fit=max&auto=format&n=tVR0kaoXvgs3p2Wx&q=85&s=aa51f91561d0dcc9b9e37570c787e465" alt="Configure Service Connection" width="1450" height="1478" data-path="public/images/ai-2.0/connectors/metadata-ingestion/Pipeline/connection-details/openlineage.png" />

* **Broker Configuration**: Choose the event broker OpenLineage events are read from: **Kafka** or **Kinesis**.
  * **Kafka**: Kafka broker configuration for OpenLineage events.
    * **Kafka Brokers List**: Kafka bootstrap servers URL.
    * **Topic Name**: Topic from where OpenLineage events will be pulled.
    * **Consumer Group** (Optional): Kafka consumer group name.
    * **Initial Consumer Offsets** (Optional): Initial Kafka consumer offset. Options are `earliest` and `latest`. Defaults to `earliest`.
    * **Single Pool Call Timeout** (Optional): Max allowed wait time. Defaults to `1`.
    * **Broker Inactive Session Timeout** (Optional): Max allowed inactivity time. Defaults to `30`.
    * **Kafka Security Protocol** (Optional): Kafka security protocol config. Options are `PLAINTEXT`, `SASL_PLAINTEXT`, `SSL`, and `SASL_SSL`. Defaults to `PLAINTEXT`.
    * **SSL** (Optional): SSL configuration details, used when the security protocol requires a certificate.
    * **SASL** (Optional): SASL configuration details, used when the security protocol requires SASL authentication.
      * **SASL Mechanism**: SASL security mechanism. Defaults to `PLAIN`.
      * **SASL Username**: The SASL authentication username.
      * **SASL Password**: The SASL authentication password.
  * **Kinesis**: AWS Kinesis Data Streams configuration for OpenLineage events.
    * **Stream Name**: Kinesis Data Stream name.
    * **Initial Consumer Offsets** (Optional): Initial Kinesis shard iterator type. Options are `TRIM_HORIZON` and `LATEST`. Defaults to `TRIM_HORIZON`.
    * **Poll Interval** (Optional): Poll interval in seconds. Defaults to `1`.
    * **Session Timeout** (Optional): Max inactivity timeout in seconds. Defaults to `30`.
    * **AWS Credentials Configuration**: AWS credentials configuration.
      * **Enable IAM Auth** (Optional): Enable AWS IAM authentication. When enabled, uses the default credential provider chain (environment variables, instance profile, and so on). Defaults to `false` for backward compatibility.
      * **AWS Access Key ID** (Optional): AWS Access Key ID.
      * **AWS Secret Access Key** (Optional): AWS Secret Access Key.
      * **AWS Region**: AWS Region.
      * **AWS Session Token** (Optional): AWS Session Token.
      * **Endpoint URL** (Optional): Endpoint URL for AWS.
      * **Profile Name** (Optional): The name of a profile to use with the boto session.
      * **Role Arn for Assume Role** (Optional): The Amazon Resource Name (ARN) of the role to assume. Required if you're using Assume Role.
      * **Role Session Name for Assume Role** (Optional): An identifier for the assumed role session. Use this to uniquely identify a session when the same role is assumed by different principals or for different reasons. Required if you're using Assume Role. Defaults to `OpenMetadataSession`.
      * **Source Identity for Assume Role** (Optional): The Amazon Resource Name (ARN) of the role to assume. Optional field for Assume Role.
* **Namespace to Service Mapping** (Optional): Map OpenLineage dataset namespaces (or prefixes) to Collate database service names. Use this when multiple services of the same type exist. For example, map `mysql://cluster-a:3306` to `mysql-cluster-a`.

<Tip>
  **Tip**: When using a **Hybrid Ingestion Runner**, any sensitive credential fields—such as passwords, API keys, or private keys—must reference secrets using the following format:

  ```
  password: secret:/my/database/password
  ```

  This applies **only to fields marked as secrets** in the connection form (these typically mask input and show a visibility toggle icon).
  For more information about managing secrets in hybrid setups, see the [Hybrid Ingestion Runner Secret Management Guide](/ai-2-0/getting-started/lets-get-started/ingest-your-data/hybrid-ingestion-runner#manage-secrets)
</Tip>

#### Test Connection

Once the credentials have been added, click on **Test Connection** and **Save** the changes.

<img src="https://mintcdn.com/collatedocs/bv5oe4uRjuorTJO1/public/images/ai-2.0/connectors/metadata-ingestion/test-connection.png?fit=max&auto=format&n=bv5oe4uRjuorTJO1&q=85&s=3365cff7bb9d82c85a2ff9ab559d6f11" alt="Test Connection" width="1446" height="188" data-path="public/images/ai-2.0/connectors/metadata-ingestion/test-connection.png" />

### Step 5: Configure Ingestion Options

In the **What to Ingest** step, use filter patterns to control which assets Collate ingests from your pipeline service. Filter patterns use regular expressions applied to pipeline names.

#### How Filter Patterns Work

* **Include**: Add one or more comma-separated regular expressions. Collate ingests only assets whose names match at least one expression. Leave blank to include all assets.
* **Exclude**: Add one or more comma-separated regular expressions. Collate skips any asset whose name matches an expression. Leave blank to exclude nothing.

Rules match asset names using one of five expressions:

* **contains**: matches any name containing the value. For example, `sales` matches `my_sales_data` and `sales_2024`.
* **starts with**: matches names beginning with the value. For example, `prod_` matches `prod_db` and `prod_schema`.
* **ends with**: matches names ending with the value. For example, `_raw` matches `events_raw` and `logs_raw`.
* **is exactly**: matches the exact name only. For example, `analytics` matches only `analytics`.
* **matches regex**: matches names using a regular expression. For example, `^prod_.*_v\d+$` matches `prod_events_v1`.

When both Include and Exclude are set, Exclude takes priority.

<Tip>
  **Tip**: Leave the filter pattern empty to ingest all pipelines available in the source.
</Tip>

#### Filter Options

The Pipeline section includes one filter option, **Pipeline**, which controls which pipelines (DAGs, jobs, or workflows) Collate ingests from the source.

Each section provides the following controls:

* **Scan Mode**: Choose one of the following scan modes:
  * **Scan all**: Ingests every asset of that type the connector can access. This is the default.
  * **Only specific**: Enables include rules so only assets matching at least one rule are ingested.
* **Exclude system toggle**: Use this toggle to automatically filter out system-reserved names defined by the connector—for example, **Exclude system databases** for the Databases section.
* **Always exclude**: Add permanent exclusion rules (shown in red). Assets matching these rules are never ingested, regardless of include rules.
* **Preview**: Shows a real-time summary of what will be in scope based on your current rules.
* **Include rules** *(available only in **Only specific** mode)*: Click **+ Add** to define a rule. Added rules appear as chips; an asset is included if it matches any rule.

<Tip>
  **Tip**: If [AutoPilot](/ai-2-0/admin-guide/applications/autopilot) is enabled, lineage between pipeline tasks and data assets is tracked automatically after the first metadata ingestion completes.
</Tip>

### Step 6: Create & Deploy

Click **Create & Deploy** to deploy the agent and start the first metadata ingestion run. Collate saves the service configuration and immediately begins pulling metadata from the source.

To monitor ingestion progress or view the service you just added, go to **Connections** in the left navigation and select your service.

## Configure Metadata Agent and Schedule Ingestion

The **Metadata Agent** extracts pipelines, tasks, and other structural metadata from your source and keeps your Collate catalog in sync. It powers discovery, lineage, and governance across your data assets.

When you click **Create & Deploy**, Collate automatically deploys a Metadata Agent for this service and triggers the first ingestion run. View its status and run history from the **Agents** tab on the service detail page.

To configure the additional Metadata Agent and schedule ingestion, follow these steps:

1. In the left navigation, click **Connections** and select your service.

2. Click the **Agents** tab.

3. Click **Add Agent** and select **Metadata** from the dropdown.
   <img src="https://mintcdn.com/collatedocs/bv5oe4uRjuorTJO1/public/images/ai-2.0/connectors/metadata-ingestion/add-metadata-agent.png?fit=max&auto=format&n=bv5oe4uRjuorTJO1&q=85&s=accad7d1c4ddf209781bff851d51d464" alt="Add Metadata Agent" width="2398" height="1144" data-path="public/images/ai-2.0/connectors/metadata-ingestion/add-metadata-agent.png" />
   For some services, the dropdown is not available and clicking **Add Agent** takes you directly to the agent configuration page.

4. On the **Configure Ingestion** page, do the following and click **Next**.

   * **Name this Ingestion**: Enter a unique recognizable name for this ingestion pipeline.

     <img src="https://mintcdn.com/collatedocs/bv5oe4uRjuorTJO1/public/images/ai-2.0/connectors/metadata-ingestion/metadata-agent-name.png?fit=max&auto=format&n=bv5oe4uRjuorTJO1&q=85&s=d5ec1f0f3742cadab8cd54c602c97239" alt="Name this Ingestion" width="1578" height="644" data-path="public/images/ai-2.0/connectors/metadata-ingestion/metadata-agent-name.png" />

   * **Agent Setup**: Configure the core parameters for this agent. The following fields are available:

     | Field                        | Default | Description                                                                                                                                                                                                                    |
     | ---------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
     | Ownership Update Mode        | replace | Set how owners from source metadata update Pipeline owners. In replace mode, resolved owners from the current source replace existing owners. In append mode, resolved owners are appended to active existing Pipeline owners. |
     | Db Service Names             | —       | List of database service names used for lineage resolution.                                                                                                                                                                    |
     | Storage Service Names        | —       | List of storage service names used for lineage resolution.                                                                                                                                                                     |
     | Messaging Service Names      | —       | List of messaging service names used for lineage resolution.                                                                                                                                                                   |
     | Status Lookback Days         | 1       | Number of days of pipeline run status history to ingest. Only runs within the last N days will be fetched.                                                                                                                     |
     | Include Lineage              | On      | Turn off to stop fetching lineage from pipelines.                                                                                                                                                                              |
     | Mark Deleted Pipeline        | On      | Soft-delete pipelines in Collate when they are removed from the source. Associated entities like lineage are also deleted.                                                                                                     |
     | Include UnDeployed Pipelines | On      | Toggle whether un-deployed pipelines should be ingested. If set to false, only deployed pipelines will be ingested.                                                                                                            |

     <img src="https://mintcdn.com/collatedocs/tVR0kaoXvgs3p2Wx/public/images/ai-2.0/connectors/metadata-ingestion/Pipeline/pipeline-agent-setup.png?fit=max&auto=format&n=tVR0kaoXvgs3p2Wx&q=85&s=471bc2416115b020f9ff6909bb9e3d89" alt="Agent Setup" width="1564" height="1476" data-path="public/images/ai-2.0/connectors/metadata-ingestion/Pipeline/pipeline-agent-setup.png" />

   * **Filter Patterns**: Apply include or exclude rules to scope which pipelines this agent ingests. These follow the same filter options described in **Step 5**.

     <img src="https://mintcdn.com/collatedocs/tVR0kaoXvgs3p2Wx/public/images/ai-2.0/connectors/metadata-ingestion/Pipeline/pipeline-filter-pattern.png?fit=max&auto=format&n=tVR0kaoXvgs3p2Wx&q=85&s=46f6f78c05d40a88a3fe9471f0f31505" alt="Filter Patterns" width="1550" height="374" data-path="public/images/ai-2.0/connectors/metadata-ingestion/Pipeline/pipeline-filter-pattern.png" />

   * **Scope & Behaviour**: Control what metadata to include and how to handle deletions. Toggle each option on or off based on your needs:

     | Toggle            | Default | Description                                                                                                                                                            |
     | ----------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
     | Enable Debug Log  | Off     | Sets the ingestion log level to DEBUG. Useful for troubleshooting.                                                                                                     |
     | Override Metadata | Off     | When on, source values overwrite existing descriptions, tags, owners, and display names in Collate. When off, Collate only updates fields that have no existing value. |
     | Override Lineage  | Off     | When on, existing lineage is replaced with newly extracted lineage on each run.                                                                                        |

     <img src="https://mintcdn.com/collatedocs/tVR0kaoXvgs3p2Wx/public/images/ai-2.0/connectors/metadata-ingestion/Pipeline/pipeline-scope-behaviour.png?fit=max&auto=format&n=tVR0kaoXvgs3p2Wx&q=85&s=38c7ce4ce152231ee67e2d0519d2fa47" alt="Scope & Behaviour" width="1570" height="1022" data-path="public/images/ai-2.0/connectors/metadata-ingestion/Pipeline/pipeline-scope-behaviour.png" />

5. On the **Schedule Interval** page, set when the agent runs:

   * **Schedule**: Choose a preset interval (Hourly, Daily, Weekly, Monthly) or enter a custom cron expression.
   * **On-Demand**: No automatic schedule; trigger the agent manually when needed.

   <img src="https://mintcdn.com/collatedocs/bv5oe4uRjuorTJO1/public/images/ai-2.0/connectors/metadata-ingestion/schedule.png?fit=max&auto=format&n=bv5oe4uRjuorTJO1&q=85&s=25cc1d78f6f2a8bd115830d034d1d8d1" alt="Schedule Interval" width="1588" height="1044" data-path="public/images/ai-2.0/connectors/metadata-ingestion/schedule.png" />

6. Click **Add** to deploy the agent.

### Providing Connection Details Programmatically via API

#### 1. Preparing the Client

```python theme={null}
from metadata.sdk import configure

configure(host="http://localhost:8585/api", jwt_token="<token>")
```

#### 2. Creating the OpenLineage pipeline service (Kafka)

```python theme={null}
from metadata.sdk import client
from metadata.generated.schema.api.services.createPipelineService import CreatePipelineServiceRequest
from metadata.generated.schema.entity.services.pipelineService import (
    PipelineServiceType,
    PipelineConnection,
)
from metadata.generated.schema.entity.services.connections.pipeline.openLineageConnection import (
    OpenLineageConnection,
    KafkaBrokerConfig,
    SecurityProtocol as KafkaSecurityProtocol,
    ConsumerOffsets
)
from metadata.generated.schema.security.ssl.validateSSLClientConfig import (
    ValidateSslClientConfig,
)

openlineage_service_request = CreatePipelineServiceRequest(
    name='openlineage-kafka-service',
    displayName='OpenLineage Kafka Service',
    serviceType=PipelineServiceType.OpenLineage,
    connection=PipelineConnection(
        config=OpenLineageConnection(
            brokerConfig=KafkaBrokerConfig(
                brokersUrl='broker1:9092,broker2:9092',
                topicName='openlineage-events',
                consumerGroupName='openmetadata-consumer',
                consumerOffsets=ConsumerOffsets.earliest,
                poolTimeout=3.0,
                sessionTimeout=60,
                securityProtocol=KafkaSecurityProtocol.SSL,
                sslConfig=ValidateSslClientConfig(
                    sslCertificate='/path/to/kafka/certs/Certificate.pem',
                    sslKey='/path/to/kafka/certs/Key.pem',
                    caCertificate='/path/to/kafka/certs/RootCA.pem'
                )
            )
        )
    ),
)
client().ometa.create_or_update(openlineage_service_request)
```

#### 3. Creating the OpenLineage pipeline service (Kinesis)

```python theme={null}
from metadata.sdk import client
from metadata.generated.schema.api.services.createPipelineService import CreatePipelineServiceRequest
from metadata.generated.schema.entity.services.pipelineService import (
    PipelineServiceType,
    PipelineConnection,
)
from metadata.generated.schema.entity.services.connections.pipeline.openLineageConnection import (
    OpenLineageConnection,
    KinesisBrokerConfig,
    KinesisConsumerOffsets
)
from metadata.generated.schema.security.credentials.awsCredentials import AWSCredentials

openlineage_service_request = CreatePipelineServiceRequest(
    name='openlineage-kinesis-service',
    displayName='OpenLineage Kinesis Service',
    serviceType=PipelineServiceType.OpenLineage,
    connection=PipelineConnection(
        config=OpenLineageConnection(
            brokerConfig=KinesisBrokerConfig(
                streamName='openlineage-events',
                consumerOffsets=KinesisConsumerOffsets.TRIM_HORIZON,
                poolTimeout=1.0,
                sessionTimeout=30,
                awsConfig=AWSCredentials(
                    awsRegion='us-east-2',
                    awsAccessKeyId='<your-access-key>',
                    awsSecretAccessKey='<your-secret-key>',
                    # awsSessionToken='<session-token>',
                )
            )
        )
    ),
)
client().ometa.create_or_update(openlineage_service_request)
```

## Troubleshooting

<Columns cols={2}>
  <Card title="OpenLineage Troubleshooting" href="/ai-2-0/connectors/pipeline/openlineage/troubleshooting">
    Learn more about how to troubleshoot common OpenLineage connector issues and resolve configuration or ingestion errors.
  </Card>
</Columns>
