OpenLineage Hybrid Runner

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

Requirements
Metadata Ingestion
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:

Install the appropriate provider in Airflow.
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.

Spark OpenLineage Events (Kafka)

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

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:

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

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

Step 2: Select a Service and Connector

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

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.

Note: The service name cannot be changed after it is set.

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.

Enter Connection Details

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

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: 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

Test Connection

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

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: Leave the filter pattern empty to ingest all pipelines available in the source.

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: If AutoPilot is enabled, lineage between pipeline tasks and data assets is tracked automatically after the first metadata ingestion completes.

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:

In the left navigation, click Connections and select your service.
Click the Agents tab.
Click Add Agent and select Metadata from the dropdown. For some services, the dropdown is not available and clicking Add Agent takes you directly to the agent configuration page.

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

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

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.

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

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.

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.
Click Add to deploy the agent.

Providing Connection Details Programmatically via API

1. Preparing the Client

from metadata.sdk import configure

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

2. Creating the OpenLineage pipeline service (Kafka)

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)

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

OpenLineage Troubleshooting

Learn more about how to troubleshoot common OpenLineage connector issues and resolve configuration or ingestion errors.

Connectors

Connectors

Requirements

OpenLineage Connector Events

Kafka Configuration

Airflow OpenLineage Events (Kafka)

Spark OpenLineage Events (Kafka)

AWS Kinesis Configuration

Kinesis Requirements

Spark OpenLineage Events (Kinesis)

Metadata Ingestion

Step 1: Add New Service

Step 2: Select a Service and Connector

Step 3: Add Service Name and Description

Step 4: Configure Connection Options

Select Ingestion Runner

Enter Connection Details

Test Connection

Step 5: Configure Ingestion Options

How Filter Patterns Work

Step 6: Create & Deploy

Configure Metadata Agent and Schedule Ingestion

Providing Connection Details Programmatically via API

1. Preparing the Client

2. Creating the OpenLineage pipeline service (Kafka)

3. Creating the OpenLineage pipeline service (Kinesis)

Troubleshooting

OpenLineage Troubleshooting

​Requirements

​OpenLineage Connector Events

​Kafka Configuration

​Airflow OpenLineage Events (Kafka)

​Spark OpenLineage Events (Kafka)

​AWS Kinesis Configuration

​Kinesis Requirements

​Spark OpenLineage Events (Kinesis)

​Metadata Ingestion

​Step 1: Add New Service

​Step 2: Select a Service and Connector

​Step 3: Add Service Name and Description

​Step 4: Configure Connection Options

​Select Ingestion Runner

​Enter Connection Details

​Test Connection

​Step 5: Configure Ingestion Options

​How Filter Patterns Work

​Filter Options

​Step 6: Create & Deploy

​Configure Metadata Agent and Schedule Ingestion

​Providing Connection Details Programmatically via API

​1. Preparing the Client

​2. Creating the OpenLineage pipeline service (Kafka)

​3. Creating the OpenLineage pipeline service (Kinesis)

​Troubleshooting

OpenLineage Troubleshooting

Requirements

OpenLineage Connector Events

Kafka Configuration

Airflow OpenLineage Events (Kafka)

Spark OpenLineage Events (Kafka)

AWS Kinesis Configuration

Kinesis Requirements

Spark OpenLineage Events (Kinesis)

Metadata Ingestion

Step 1: Add New Service

Step 2: Select a Service and Connector

Step 3: Add Service Name and Description

Step 4: Configure Connection Options

Select Ingestion Runner

Enter Connection Details

Test Connection

Step 5: Configure Ingestion Options

How Filter Patterns Work

Filter Options

Step 6: Create & Deploy

Configure Metadata Agent and Schedule Ingestion

Providing Connection Details Programmatically via API

1. Preparing the Client

2. Creating the OpenLineage pipeline service (Kafka)

3. Creating the OpenLineage pipeline service (Kinesis)

Troubleshooting