Protobuf

The druid-protobuf-extensions provides the Protobuf Parser for . See corresponding docs for details.

This example demonstrates how to load Protobuf messages from Kafka. Please read the first, and see Kafka Indexing Service documentation for more details.

The files used in this example are found at .

For this example:

Kafka broker host is localhost:9092
Kafka topic is metrics_pb
Datasource name is metrics-protobuf

Here is a JSON example of the ‘metrics’ data schema used in the example.

The corresponding proto file for our ‘metrics’ dataset looks like this. You can use Protobuf inputFormat with a proto file or .

syntax = "proto3";
message Metrics {
  string unit = 1;
  string http_method = 2;
  int32 value = 3;
  string timestamp = 4;
  string http_code = 5;
  string page = 6;
  string metricType = 7;
  string server = 8;
}

When using a descriptor file

Next, we use the protoc Protobuf compiler to generate the descriptor file and save it as metrics.desc. The descriptor file must be either in the classpath or reachable by URL. In this example the descriptor file was saved at /tmp/metrics.desc, however this file is also available in the example files. From your Druid install directory:

protoc -o /tmp/metrics.desc ./quickstart/protobuf/metrics.proto

POST /subjects/test/versions HTTP/1.1
Host: schemaregistry.example1.com
Accept: application/vnd.schemaregistry.v1+json, application/vnd.schemaregistry+json, application/json
{
    "schemaType": "PROTOBUF",
    "schema": "syntax = \"proto3\";\nmessage Metrics {\n  string unit = 1;\n  string http_method = 2;\n  int32 value = 3;\n string timestamp = 4;\n string http_code = 5;\n string page = 6;\n string metricType = 7;\n string server = 8;\n}\n"

This feature uses Confluent’s Protobuf provider which is not included in the Druid distribution and must be installed separately. You can fetch it and its dependencies from the Confluent repository and Maven Central at:

Copy or symlink those files inside the folder extensions/protobuf-extensions under the distribution root directory.

Below is the complete Supervisor spec JSON to be submitted to the Overlord. Make sure these keys are properly configured for successful ingestion.

When using a descriptor file

Important supervisor properties

protoBytesDecoder.descriptor for the descriptor file URL
protoBytesDecoder.protoMessageType from the proto definition
protoBytesDecoder.type set to file, indicate use descriptor file to decode Protobuf file
inputFormat should have type set to protobuf

To adopt to old version. You can use old parser style, which also works.


  "parser": {
    "type": "protobuf",
    "descriptor": "file:///tmp/metrics.desc",
    "protoMessageType": "Metrics"
  }
}

Important supervisor properties

protoBytesDecoder.url for the schema registry URL with single instance.
protoBytesDecoder.urls for the schema registry URLs with multi instances.
protoBytesDecoder.capacity capacity for schema registry cached schemas.
protoBytesDecoder.config to send additional configurations, configured for Schema Registry.
protoBytesDecoder.headers to send headers to the Schema Registry.
protoBytesDecoder.type set to schema_registry, indicate use schema registry to decode Protobuf file.
parser should have type set to protobuf, but note that the format of the parseSpec must be json.

{
  "parser": {
    "type": "protobuf",
    "protoBytesDecoder": {
      "urls": ["http://schemaregistry.example1.com:8081","http://schemaregistry.example2.com:8081"],
      "type": "schema_registry",
      "capacity": 100,
      "config" : {
           "basic.auth.credentials.source": "USER_INFO",
           "basic.auth.user.info": "fred:letmein",
           "schema.registry.ssl.truststore.location": "/some/secrets/kafka.client.truststore.jks",
           "schema.registry.ssl.truststore.password": "<password>",
           "schema.registry.ssl.keystore.location": "/some/secrets/kafka.client.keystore.jks",
           "schema.registry.ssl.key.password": "<password>",
             ... 
      },
      "headers": {
          "traceID" : "b29c5de2-0db4-490b-b421",
          "timeStamp" : "1577191871865",
      }
    }
  }
}

If necessary, from your Kafka installation directory run the following command to create the Kafka topic

./bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic metrics_pb

You can confirm that data has been inserted to your Kafka topic using the following command from your Kafka installation directory

./bin/kafka-console-consumer --zookeeper localhost --topic metrics_pb

which should print messages like this

millisecondsGETR"2017-04-06T03:23:56Z*2002/list:request/latencyBwww1.example.com

If your supervisor created in the previous step is running, the indexing tasks should begin producing the messages and the data will soon be available for querying in Druid.

The files provided in the example quickstart can be generated in the following manner starting with only metrics.proto.

`metrics.desc`

The descriptor file is generated using protoc Protobuf compiler. Given a .proto file, a .desc file can be generated like so.

protoc -o metrics.desc metrics.proto

metrics_pb2.py is also generated with protoc

`pb_publisher.py`

After metrics_pb2.py is generated, another script can be constructed to parse JSON data, convert it to Protobuf, and produce to a Kafka topic

#!/usr/bin/env python
import sys
import json
from kafka import KafkaProducer
from metrics_pb2 import Metrics
producer = KafkaProducer(bootstrap_servers='localhost:9092')
topic = 'metrics_pb'
for row in iter(sys.stdin):
    d = json.loads(row)
    metrics = Metrics()
    for k, v in d.items():
        setattr(metrics, k, v)
    pb = metrics.SerializeToString()
    producer.send(topic, pb)
producer.flush()