fluent-plugin-opentelemetry 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8f0a6c1b314b0737a832920decef09f6066acd10d578271b65edc4bc535b540
-  data.tar.gz: b5b1fd56d7c410ac7decfc50b67459277cb14d1a20b762bfdc414edaeaf1f4ef
+  metadata.gz: 7e88abfcc25a1079994f2801f2b32665bb39bb32408cff6efb91125ef9b60149
+  data.tar.gz: 2b64e708b7ea494e4c35e4218c4f33e2ca15f04ac55672d95dc9d7456435303c
 SHA512:
-  metadata.gz: fe86042e9aa128f24f0479332aee03e753ef82e6e04fe34b6d49cc1226753f2ca26a775d5b938cce67cf02b710f5230c8106f278cb5afc19dc69faefc439a3c5
-  data.tar.gz: 65c174366007116fd6b7fa2422914224414f5ec7c976732550d448fd219edd25c7b413e1a077ad243ab341d2e2fbd688369e1c525ba417c8418c32d5d17532b2
+  metadata.gz: 26fde29bef629246d797440d306b863ed6ed8cd57d0871f6c66b52b0c3109b453e6d836cb5b99d5b545d778cbb9f4893fdc37166499baf61e92de5bf478f60c5
+  data.tar.gz: 1510198977d2f3b71a58a7a85e9a948b40716bf036c84968b8bb5c1507d63553fd1a06dbc70633d788d110dbc510ef898710eaaf2727d76adfd8baba9b5c9e81

data/.rubocop.yml

@@ -1,3 +1,7 @@
+plugins:
+  - rubocop-performance
+  - rubocop-fluentd
+
 AllCops:
   Exclude:
     - 'lib/opentelemetry/**/*'
@@ -6,12 +10,27 @@ AllCops:
   SuggestExtensions: false
   TargetRubyVersion: 3.2
 
+# rubocop-fluentd
+Lint/FluentdPluginLogScope:
+  Enabled: true
+Lint/FluentdPluginConfigParamDefaultTime:
+  Enabled: true
+Performance/FluentdPluginLogStringInterpolation:
+  Enabled: true
+
+# rubocop
+Gemspec/DevelopmentDependencies:
+  Enabled: false
+
 Layout/LineLength:
   Enabled: false
 
 Lint/UnusedMethodArgument:
   Enabled: false
 
+Lint/SuppressedException:
+  Enabled: false
+
 Metrics:
   Enabled: false
 

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [0.3.0] - 2025-07-23
+
+- in_opentelemetry: add ${type} placeholder support in tag parameter (#8)
+- in_opentelemetry: use String for record keys (#6)
+
+## [0.2.0] - 2025-06-26
+
+- Make gRPC sending and receiving optional (#4)
+  - To use gRPC sending and receiving, you need to install `grpc` gem manually.
+
 ## [0.1.0] - 2025-03-31
 
 - Initial release

data/README.md

@@ -34,6 +34,33 @@ To receive data, this plugin requires `<http>` or `<grpc>` section, or both.
 |-----------|--------|----------------------|----------|
 | tag       | string | The tag of the event | required |
 
+`tag` parameter supports `${type}` placeholder and it will be expanded with data type.
+
+* log data
+  * `${type}` will be replaced to `logs`
+* metric data
+  * `${type}` will be replaced to `metrics`
+* trace data
+  * `${type}` will be replaced to `traces`
+
+This can be used to change the output destination for each message type.
+
+Example:
+
+```
+<source>
+  @type opentelemetry
+
+  # Expand to opentelemetry.logs, opentelemetry.metrics, opentelemetry.traces according to received data.
+  tag opentelemetry.${type}
+
+  <http>
+    bind 127.0.0.1
+    port 4318
+  </http>
+</source>
+```
+
 #### `<http>` section
 
 This requires to receive data via HTTP/HTTPS.
@@ -46,6 +73,7 @@ This requires to receive data via HTTP/HTTPS.
 #### `<grpc>` section
 
 This requires to receive data via gRPC.
+It needs to install `grpc` gem manually to use this feature.
 
 > [!WARNING]
 > Now, gRPC feature status is experimental.
@@ -53,7 +81,7 @@ This requires to receive data via gRPC.
 | parameter | type    | description            | default   |
 |-----------|---------|------------------------|-----------|
 | bind      | string  | The address to bind to | `0.0.0.0` |
-| port      | integer | The port to listen to  | `4318`    |
+| port      | integer | The port to listen to  | `4317`    |
 
 * `<transport>` section
 
@@ -103,6 +131,7 @@ This requires to send data via HTTP/HTTPS.
 #### `<grpc>` section
 
 This requires to send data via gRPC.
+It needs to install `grpc` gem manually to use this feature.
 
 > [!WARNING]
 > Now, gRPC feature status is experimental.

data/lib/fluent/plugin/in_opentelemetry.rb

@@ -2,29 +2,15 @@
 
 require "fluent/plugin/input"
 require "fluent/plugin/opentelemetry/constant"
-require "fluent/plugin/opentelemetry/request"
-require "fluent/plugin/opentelemetry/response"
-require "fluent/plugin/opentelemetry/service_handler"
+require "fluent/plugin/opentelemetry/http_input_handler"
 require "fluent/plugin_helper/http_server"
 require "fluent/plugin_helper/thread"
 
-require "zlib"
-
-unless Fluent::PluginHelper::HttpServer::Request.method_defined?(:headers)
-  # This API was introduced at fluentd v1.19.0.
-  # Ref. https://github.com/fluent/fluentd/pull/4903
-  # If we have supported v1.19.0+ only, we can remove this patch.
-  module Fluent::PluginHelper::HttpServer
-    module Extension
-      refine Request do
-        def headers
-          @request.headers
-        end
-      end
-    end
-  end
+begin
+  require "grpc"
 
-  using Fluent::PluginHelper::HttpServer::Extension
+  require "fluent/plugin/opentelemetry/grpc_input_handler"
+rescue LoadError
 end
 
 module Fluent::Plugin
@@ -57,6 +43,12 @@ module Fluent::Plugin
     def configure(conf)
       super
 
+      expand_tag_placeholders(@tag)
+
+      if @grpc_config && !defined?(GRPC)
+        raise Fluent::ConfigError, "To use gRPC feature, please install grpc gem such as 'fluent-gem install grpc'."
+      end
+
       unless [@http_config, @grpc_config].any?
         raise Fluent::ConfigError, "Please configure either <http> or <grpc> section, or both."
       end
@@ -66,146 +58,50 @@ module Fluent::Plugin
       super
 
       if @http_config
-        http_handler = HttpHandler.new
+        http_handler = Opentelemetry::HttpInputHandler.new
         http_server_create_http_server(:in_opentelemetry_http_server, addr: @http_config.bind, port: @http_config.port, logger: log) do |serv|
           serv.post("/v1/logs") do |req|
-            http_handler.logs(req) { |record| router.emit(@tag, Fluent::EventTime.now, { type: Opentelemetry::RECORD_TYPE_LOGS, message: record }) }
+            http_handler.logs(req) { |record| router.emit(tag_for(Opentelemetry::RECORD_TYPE_LOGS), Fluent::EventTime.now, { "type" => Opentelemetry::RECORD_TYPE_LOGS, "message" => record }) }
           end
           serv.post("/v1/metrics") do |req|
-            http_handler.metrics(req) { |record| router.emit(@tag, Fluent::EventTime.now, { type: Opentelemetry::RECORD_TYPE_METRICS, message: record }) }
+            http_handler.metrics(req) { |record| router.emit(tag_for(Opentelemetry::RECORD_TYPE_METRICS), Fluent::EventTime.now, { "type" => Opentelemetry::RECORD_TYPE_METRICS, "message" => record }) }
           end
           serv.post("/v1/traces") do |req|
-            http_handler.traces(req) { |record| router.emit(@tag, Fluent::EventTime.now, { type: Opentelemetry::RECORD_TYPE_TRACES, message: record }) }
+            http_handler.traces(req) { |record| router.emit(tag_for(Opentelemetry::RECORD_TYPE_TRACES), Fluent::EventTime.now, { "type" => Opentelemetry::RECORD_TYPE_TRACES, "message" => record }) }
           end
         end
       end
 
       if @grpc_config
         thread_create(:in_opentelemetry_grpc_server) do
-          grpc_handler = GrpcHandler.new(@grpc_config, log)
+          grpc_handler = Opentelemetry::GrpcInputHandler.new(@grpc_config, log)
           grpc_handler.run(
             logs: lambda { |record|
-              router.emit(@tag, Fluent::EventTime.now, { type: Opentelemetry::RECORD_TYPE_LOGS, message: record })
+              router.emit(tag_for(Opentelemetry::RECORD_TYPE_LOGS), Fluent::EventTime.now, { "type" => Opentelemetry::RECORD_TYPE_LOGS, "message" => record })
             },
             metrics: lambda { |record|
-              router.emit(@tag, Fluent::EventTime.now, { type: Opentelemetry::RECORD_TYPE_METRICS, message: record })
+              router.emit(tag_for(Opentelemetry::RECORD_TYPE_METRICS), Fluent::EventTime.now, { "type" => Opentelemetry::RECORD_TYPE_METRICS, "message" => record })
             },
             traces: lambda { |record|
-              router.emit(@tag, Fluent::EventTime.now, { type: Opentelemetry::RECORD_TYPE_TRACES, message: record })
+              router.emit(tag_for(Opentelemetry::RECORD_TYPE_TRACES), Fluent::EventTime.now, { "type" => Opentelemetry::RECORD_TYPE_TRACES, "message" => record })
             }
           )
         end
       end
     end
 
-    class HttpHandler
-      def logs(req, &block)
-        common(req, Opentelemetry::Request::Logs, Opentelemetry::Response::Logs, &block)
-      end
-
-      def metrics(req, &block)
-        common(req, Opentelemetry::Request::Metrics, Opentelemetry::Response::Metrics, &block)
-      end
+    private
 
-      def traces(req, &block)
-        common(req, Opentelemetry::Request::Traces, Opentelemetry::Response::Traces, &block)
-      end
-
-      private
-
-      def common(req, request_class, response_class)
-        content_type = req.headers["content-type"]
-        content_encoding = req.headers["content-encoding"]&.first
-        return response_unsupported_media_type unless valid_content_type?(content_type)
-        return response_bad_request(content_type) unless valid_content_encoding?(content_encoding)
-
-        body = req.body
-        body = Zlib::GzipReader.new(StringIO.new(body)).read if content_encoding == Opentelemetry::CONTENT_ENCODING_GZIP
-
-        begin
-          record = request_class.new(body).record
-        rescue Google::Protobuf::ParseError
-          # The format in request body does not comply with the OpenTelemetry protocol.
-          return response_bad_request(content_type)
-        end
-
-        yield record
-
-        res = response_class.new
-        response(200, content_type, res.body(type: Opentelemetry::Response.type(content_type)))
-      end
-
-      def valid_content_type?(content_type)
-        case content_type
-        when Opentelemetry::CONTENT_TYPE_PROTOBUF, Opentelemetry::CONTENT_TYPE_JSON
-          true
-        else
-          false
-        end
-      end
-
-      def valid_content_encoding?(content_encoding)
-        return true if content_encoding.nil?
-
-        content_encoding == Opentelemetry::CONTENT_ENCODING_GZIP
-      end
-
-      def response(code, content_type, body)
-        [code, { Opentelemetry::CONTENT_TYPE => content_type }, body]
-      end
-
-      def response_unsupported_media_type
-        response(415, Opentelemetry::CONTENT_TYPE_PAIN, "415 unsupported media type, supported: [application/json, application/x-protobuf]")
-      end
-
-      def response_bad_request(content_type)
-        response(400, content_type, "") # TODO: fix body message
-      end
+    def expand_tag_placeholders(tag)
+      @expand_tag_placeholders ||= {
+        Opentelemetry::RECORD_TYPE_LOGS => tag.gsub(Opentelemetry::PLACEHOLDER_TYPE, Opentelemetry::PLACEHOLDER_TYPE_LOGS),
+        Opentelemetry::RECORD_TYPE_METRICS => tag.gsub(Opentelemetry::PLACEHOLDER_TYPE, Opentelemetry::PLACEHOLDER_TYPE_METRICS),
+        Opentelemetry::RECORD_TYPE_TRACES => tag.gsub(Opentelemetry::PLACEHOLDER_TYPE, Opentelemetry::PLACEHOLDER_TYPE_TRACES)
+      }
     end
 
-    class GrpcHandler
-      class ExceptionInterceptor < GRPC::ServerInterceptor
-        def request_response(request:, call:, method:)
-          # call actual service
-          yield
-        rescue StandardError => e
-          puts "[#{method}] Error: #{e.message}"
-          raise
-        end
-      end
-
-      def initialize(grpc_config, logger)
-        @grpc_config = grpc_config
-        @logger = logger
-      end
-
-      def run(logs:, metrics:, traces:)
-        server = GRPC::RpcServer.new(interceptors: [ExceptionInterceptor.new])
-        server.add_http2_port("#{@grpc_config.bind}:#{@grpc_config.port}", :this_port_is_insecure)
-
-        logs_handler = Opentelemetry::ServiceHandler::Logs.new
-        logs_handler.callback = lambda { |request|
-          logs.call(request.to_json)
-          Opentelemetry::Response::Logs.build
-        }
-        server.handle(logs_handler)
-
-        metrics_handler = Opentelemetry::ServiceHandler::Metrics.new
-        metrics_handler.callback = lambda { |request|
-          metrics.call(request.to_json)
-          Opentelemetry::Response::Metrics.build
-        }
-        server.handle(metrics_handler)
-
-        traces_handler = Opentelemetry::ServiceHandler::Traces.new
-        traces_handler.callback = lambda { |request|
-          traces.call(request.to_json)
-          Opentelemetry::Response::Traces.build
-        }
-        server.handle(traces_handler)
-
-        server.run_till_terminated
-      end
+    def tag_for(type)
+      @expand_tag_placeholders[type]
     end
   end
 end

data/lib/fluent/plugin/opentelemetry/constant.rb

@@ -16,6 +16,11 @@ module Fluent::Plugin::Opentelemetry
   RECORD_TYPE_METRICS = "opentelemetry_metrics"
   RECORD_TYPE_TRACES = "opentelemetry_traces"
 
+  PLACEHOLDER_TYPE = "${type}"
+  PLACEHOLDER_TYPE_LOGS = "logs"
+  PLACEHOLDER_TYPE_METRICS = "metrics"
+  PLACEHOLDER_TYPE_TRACES = "traces"
+
   TLS_VERSIONS_MAP =
     begin
       map = {

data/lib/fluent/plugin/opentelemetry/grpc_input_handler.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "fluent/plugin/opentelemetry/response"
+require "opentelemetry/proto/collector/logs/v1/logs_service_services_pb"
+require "opentelemetry/proto/collector/metrics/v1/metrics_service_services_pb"
+require "opentelemetry/proto/collector/trace/v1/trace_service_services_pb"
+
+module Fluent::Plugin::Opentelemetry
+  class GrpcInputHandler
+    class ServiceHandler
+      class Logs < Opentelemetry::Proto::Collector::Logs::V1::LogsService::Service
+        def callback=(block)
+          @callback = block
+        end
+
+        def export(req, _call)
+          @callback.call(req)
+        end
+      end
+
+      class Metrics < Opentelemetry::Proto::Collector::Metrics::V1::MetricsService::Service
+        def callback=(block)
+          @callback = block
+        end
+
+        def export(req, _call)
+          @callback.call(req)
+        end
+      end
+
+      class Traces < Opentelemetry::Proto::Collector::Trace::V1::TraceService::Service
+        def callback=(block)
+          @callback = block
+        end
+
+        def export(req, _call)
+          @callback.call(req)
+        end
+      end
+    end
+
+    class ExceptionInterceptor < GRPC::ServerInterceptor
+      def request_response(request:, call:, method:)
+        # call actual service
+        yield
+      rescue StandardError => e
+        puts "[#{method}] Error: #{e.message}"
+        raise
+      end
+    end
+
+    def initialize(grpc_config, logger)
+      @grpc_config = grpc_config
+      @logger = logger
+    end
+
+    def run(logs:, metrics:, traces:)
+      server = GRPC::RpcServer.new(interceptors: [ExceptionInterceptor.new])
+      server.add_http2_port("#{@grpc_config.bind}:#{@grpc_config.port}", :this_port_is_insecure)
+
+      logs_handler = ServiceHandler::Logs.new
+      logs_handler.callback = lambda { |request|
+        logs.call(request.to_json)
+        Fluent::Plugin::Opentelemetry::Response::Logs.build
+      }
+      server.handle(logs_handler)
+
+      metrics_handler = ServiceHandler::Metrics.new
+      metrics_handler.callback = lambda { |request|
+        metrics.call(request.to_json)
+        Fluent::Plugin::Opentelemetry::Response::Metrics.build
+      }
+      server.handle(metrics_handler)
+
+      traces_handler = ServiceHandler::Traces.new
+      traces_handler.callback = lambda { |request|
+        traces.call(request.to_json)
+        Fluent::Plugin::Opentelemetry::Response::Traces.build
+      }
+      server.handle(traces_handler)
+
+      server.run_till_terminated
+    end
+  end
+end

data/lib/fluent/plugin/opentelemetry/grpc_output_handler.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "opentelemetry/proto/collector/logs/v1/logs_service_pb"
+require "opentelemetry/proto/collector/logs/v1/logs_service_services_pb"
+require "opentelemetry/proto/collector/metrics/v1/metrics_service_pb"
+require "opentelemetry/proto/collector/metrics/v1/metrics_service_services_pb"
+require "opentelemetry/proto/collector/trace/v1/trace_service_pb"
+require "opentelemetry/proto/collector/trace/v1/trace_service_services_pb"
+
+require "fluent/plugin/opentelemetry/constant"
+require "google/protobuf"
+
+class Fluent::Plugin::Opentelemetry::GrpcOutputHandler
+  class ServiceStub
+    class Logs
+      def initialize(host, creds, **kw)
+        @stub = Opentelemetry::Proto::Collector::Logs::V1::LogsService::Stub.new(host, creds, **kw)
+      end
+
+      def export(json)
+        message = Opentelemetry::Proto::Collector::Logs::V1::ExportLogsServiceRequest.decode_json(json)
+        @stub.export(message)
+      end
+    end
+
+    class Metrics
+      def initialize(host, creds, **kw)
+        @stub = Opentelemetry::Proto::Collector::Metrics::V1::MetricsService::Stub.new(host, creds, **kw)
+      end
+
+      def export(json)
+        message = Opentelemetry::Proto::Collector::Metrics::V1::ExportMetricsServiceRequest.decode_json(json)
+        @stub.export(message)
+      end
+    end
+
+    class Traces
+      def initialize(host, creds, **kw)
+        @stub = Opentelemetry::Proto::Collector::Trace::V1::TraceService::Stub.new(host, creds, **kw)
+      end
+
+      def export(json)
+        message = Opentelemetry::Proto::Collector::Trace::V1::ExportTraceServiceRequest.decode_json(json)
+        @stub.export(message)
+      end
+    end
+  end
+
+  def initialize(grpc_config, transport_config, logger)
+    @grpc_config = grpc_config
+    @transport_config = transport_config
+    @logger = logger
+  end
+
+  def export(record)
+    msg = record["message"]
+
+    credential = :this_channel_is_insecure
+
+    case record["type"]
+    when Fluent::Plugin::Opentelemetry::RECORD_TYPE_LOGS
+      service = ServiceStub::Logs.new(@grpc_config.endpoint, credential)
+    when Fluent::Plugin::Opentelemetry::RECORD_TYPE_METRICS
+      service = ServiceStub::Metrics.new(@grpc_config.endpoint, credential)
+    when Fluent::Plugin::Opentelemetry::RECORD_TYPE_TRACES
+      service = ServiceStub::Traces.new(@grpc_config.endpoint, credential)
+    end
+
+    begin
+      service.export(msg)
+    rescue Google::Protobuf::ParseError => e
+      # The message format does not comply with the OpenTelemetry protocol.
+      raise ::Fluent::UnrecoverableError, e.message
+    end
+  end
+end

data/lib/fluent/plugin/opentelemetry/http_input_handler.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "fluent/plugin/opentelemetry/constant"
+require "fluent/plugin/opentelemetry/request"
+require "fluent/plugin/opentelemetry/response"
+require "google/protobuf"
+require "zlib"
+
+unless Fluent::PluginHelper::HttpServer::Request.method_defined?(:headers)
+  # This API was introduced at fluentd v1.19.0.
+  # Ref. https://github.com/fluent/fluentd/pull/4903
+  # If we have supported v1.19.0+ only, we can remove this patch.
+  module Fluent::PluginHelper::HttpServer
+    module Extension
+      refine Request do
+        def headers
+          @request.headers
+        end
+      end
+    end
+  end
+
+  using Fluent::PluginHelper::HttpServer::Extension
+end
+
+class Fluent::Plugin::Opentelemetry::HttpInputHandler
+  def logs(req, &block)
+    common(req, Fluent::Plugin::Opentelemetry::Request::Logs, Fluent::Plugin::Opentelemetry::Response::Logs, &block)
+  end
+
+  def metrics(req, &block)
+    common(req, Fluent::Plugin::Opentelemetry::Request::Metrics, Fluent::Plugin::Opentelemetry::Response::Metrics, &block)
+  end
+
+  def traces(req, &block)
+    common(req, Fluent::Plugin::Opentelemetry::Request::Traces, Fluent::Plugin::Opentelemetry::Response::Traces, &block)
+  end
+
+  private
+
+  def common(req, request_class, response_class)
+    content_type = req.headers["content-type"]
+    content_encoding = req.headers["content-encoding"]&.first
+    return response_unsupported_media_type unless valid_content_type?(content_type)
+    return response_bad_request(content_type) unless valid_content_encoding?(content_encoding)
+
+    body = req.body
+    body = Zlib::GzipReader.new(StringIO.new(body)).read if content_encoding == Fluent::Plugin::Opentelemetry::CONTENT_ENCODING_GZIP
+
+    begin
+      record = request_class.new(body).record
+    rescue Google::Protobuf::ParseError
+      # The format in request body does not comply with the OpenTelemetry protocol.
+      return response_bad_request(content_type)
+    end
+
+    yield record
+
+    res = response_class.new
+    response(200, content_type, res.body(type: Fluent::Plugin::Opentelemetry::Response.type(content_type)))
+  end
+
+  def valid_content_type?(content_type)
+    case content_type
+    when Fluent::Plugin::Opentelemetry::CONTENT_TYPE_PROTOBUF, Fluent::Plugin::Opentelemetry::CONTENT_TYPE_JSON
+      true
+    else
+      false
+    end
+  end
+
+  def valid_content_encoding?(content_encoding)
+    return true if content_encoding.nil?
+
+    content_encoding == Fluent::Plugin::Opentelemetry::CONTENT_ENCODING_GZIP
+  end
+
+  def response(code, content_type, body)
+    [code, { Fluent::Plugin::Opentelemetry::CONTENT_TYPE => content_type }, body]
+  end
+
+  def response_unsupported_media_type
+    response(415, Fluent::Plugin::Opentelemetry::CONTENT_TYPE_PAIN, "415 unsupported media type, supported: [application/json, application/x-protobuf]")
+  end
+
+  def response_bad_request(content_type)
+    response(400, content_type, "") # TODO: fix body message
+  end
+end

data/lib/fluent/plugin/opentelemetry/http_output_handler.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "fluent/plugin/opentelemetry/constant"
+require "fluent/plugin/opentelemetry/request"
+
+require "excon"
+require "google/protobuf"
+require "stringio"
+require "zlib"
+
+class Fluent::Plugin::Opentelemetry::HttpOutputHandler
+  def initialize(http_config, transport_config, logger)
+    @http_config = http_config
+    @transport_config = transport_config
+    @logger = logger
+
+    @tls_settings = {}
+    if @transport_config.protocol == :tls
+      @tls_settings[:client_cert] = @transport_config.cert_path
+      @tls_settings[:client_key] = @transport_config.private_key_path
+      @tls_settings[:client_key_pass] = @transport_config.private_key_passphrase
+      @tls_settings[:ssl_min_version] = Fluent::Plugin::Opentelemetry::TLS_VERSIONS_MAP[@transport_config.min_version]
+      @tls_settings[:ssl_max_version] = Fluent::Plugin::Opentelemetry::TLS_VERSIONS_MAP[@transport_config.max_version]
+    end
+
+    @timeout_settings = {
+      read_timeout: http_config.read_timeout,
+      write_timeout: http_config.write_timeout,
+      connect_timeout: http_config.connect_timeout
+    }
+  end
+
+  def export(record)
+    uri, connection = create_http_connection(record)
+    response = connection.post
+
+    if response.status != 200
+      if response.status == 400
+        # The client MUST NOT retry the request when it receives HTTP 400 Bad Request response.
+        raise Fluent::UnrecoverableError, "got unrecoverable error response from '#{uri}', response code is #{response.status}"
+      end
+
+      if @http_config.retryable_response_codes&.include?(response.status)
+        raise Fluent::Plugin::OpentelemetryOutput::RetryableResponse, "got retryable error response from '#{uri}', response code is #{response.status}"
+      end
+      if @http_config.error_response_as_unrecoverable
+        raise Fluent::UnrecoverableError, "got unrecoverable error response from '#{uri}', response code is #{response.status}"
+      else
+        @logger.error "got error response from '#{uri}', response code is #{response.status}"
+      end
+    end
+  end
+
+  private
+
+  def http_logs_endpoint
+    "#{@http_config.endpoint}/v1/logs"
+  end
+
+  def http_metrics_endpoint
+    "#{@http_config.endpoint}/v1/metrics"
+  end
+
+  def http_traces_endpoint
+    "#{@http_config.endpoint}/v1/traces"
+  end
+
+  def create_http_connection(record)
+    msg = record["message"]
+
+    begin
+      case record["type"]
+      when Fluent::Plugin::Opentelemetry::RECORD_TYPE_LOGS
+        uri = http_logs_endpoint
+        body = Fluent::Plugin::Opentelemetry::Request::Logs.new(msg).body
+      when Fluent::Plugin::Opentelemetry::RECORD_TYPE_METRICS
+        uri = http_metrics_endpoint
+        body = Fluent::Plugin::Opentelemetry::Request::Metrics.new(msg).body
+      when Fluent::Plugin::Opentelemetry::RECORD_TYPE_TRACES
+        uri = http_traces_endpoint
+        body = Fluent::Plugin::Opentelemetry::Request::Traces.new(msg).body
+      end
+    rescue Google::Protobuf::ParseError => e
+      # The message format does not comply with the OpenTelemetry protocol.
+      raise ::Fluent::UnrecoverableError, e.message
+    end
+
+    headers = { Fluent::Plugin::Opentelemetry::CONTENT_TYPE => Fluent::Plugin::Opentelemetry::CONTENT_TYPE_PROTOBUF }
+    if @http_config.compress == :gzip
+      headers[Fluent::Plugin::Opentelemetry::CONTENT_ENCODING] = Fluent::Plugin::Opentelemetry::CONTENT_ENCODING_GZIP
+      gz = Zlib::GzipWriter.new(StringIO.new)
+      gz << body
+      body = gz.close.string
+    end
+
+    Excon.defaults[:ssl_verify_peer] = false if @transport_config.insecure
+    connection = Excon.new(uri, body: body, headers: headers, proxy: @http_config.proxy, persistent: true, **@tls_settings, **@timeout_settings)
+    [uri, connection]
+  end
+end

data/lib/fluent/plugin/out_opentelemetry.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
 require "fluent/plugin/opentelemetry/constant"
-require "fluent/plugin/opentelemetry/request"
-require "fluent/plugin/opentelemetry/service_stub"
+require "fluent/plugin/opentelemetry/http_output_handler"
 require "fluent/plugin/output"
 
-require "excon"
-require "grpc"
 require "json"
-require "stringio"
-require "zlib"
+
+begin
+  require "grpc"
+
+  require "fluent/plugin/opentelemetry/grpc_output_handler"
+rescue LoadError
+end
 
 module Fluent::Plugin
   class OpentelemetryOutput < Output
@@ -57,12 +59,16 @@ module Fluent::Plugin
     def configure(conf)
       super
 
+      if @grpc_config && !defined?(GRPC)
+        raise Fluent::ConfigError, "To use gRPC feature, please install grpc gem such as 'fluent-gem install grpc'."
+      end
+
       unless [@http_config, @grpc_config].one?
         raise Fluent::ConfigError, "Please configure either <http> or <grpc> section."
       end
 
-      @http_handler = HttpHandler.new(@http_config, @transport_config, log) if @http_config
-      @grpc_handler = GrpcHandler.new(@grpc_config, @transport_config, log) if @grpc_config
+      @http_handler = Opentelemetry::HttpOutputHandler.new(@http_config, @transport_config, log) if @http_config
+      @grpc_handler = Opentelemetry::GrpcOutputHandler.new(@grpc_config, @transport_config, log) if @grpc_config
     end
 
     def multi_workers_ready?
@@ -82,126 +88,5 @@ module Fluent::Plugin
         @http_handler.export(record)
       end
     end
-
-    class HttpHandler
-      def initialize(http_config, transport_config, logger)
-        @http_config = http_config
-        @transport_config = transport_config
-        @logger = logger
-
-        @tls_settings = {}
-        if @transport_config.protocol == :tls
-          @tls_settings[:client_cert] = @transport_config.cert_path
-          @tls_settings[:client_key] = @transport_config.private_key_path
-          @tls_settings[:client_key_pass] = @transport_config.private_key_passphrase
-          @tls_settings[:ssl_min_version] = Opentelemetry::TLS_VERSIONS_MAP[@transport_config.min_version]
-          @tls_settings[:ssl_max_version] = Opentelemetry::TLS_VERSIONS_MAP[@transport_config.max_version]
-        end
-
-        @timeout_settings = {
-          read_timeout: http_config.read_timeout,
-          write_timeout: http_config.write_timeout,
-          connect_timeout: http_config.connect_timeout
-        }
-      end
-
-      def export(record)
-        uri, connection = create_http_connection(record)
-        response = connection.post
-
-        if response.status != 200
-          if response.status == 400
-            # The client MUST NOT retry the request when it receives HTTP 400 Bad Request response.
-            raise Fluent::UnrecoverableError, "got unrecoverable error response from '#{uri}', response code is #{response.status}"
-          end
-
-          if @http_config.retryable_response_codes&.include?(response.status)
-            raise RetryableResponse, "got retryable error response from '#{uri}', response code is #{response.status}"
-          end
-          if @http_config.error_response_as_unrecoverable
-            raise Fluent::UnrecoverableError, "got unrecoverable error response from '#{uri}', response code is #{response.status}"
-          else
-            @logger.error "got error response from '#{uri}', response code is #{response.status}"
-          end
-        end
-      end
-
-      private
-
-      def http_logs_endpoint
-        "#{@http_config.endpoint}/v1/logs"
-      end
-
-      def http_metrics_endpoint
-        "#{@http_config.endpoint}/v1/metrics"
-      end
-
-      def http_traces_endpoint
-        "#{@http_config.endpoint}/v1/traces"
-      end
-
-      def create_http_connection(record)
-        msg = record["message"]
-
-        begin
-          case record["type"]
-          when Opentelemetry::RECORD_TYPE_LOGS
-            uri = http_logs_endpoint
-            body = Opentelemetry::Request::Logs.new(msg).body
-          when Opentelemetry::RECORD_TYPE_METRICS
-            uri = http_metrics_endpoint
-            body = Opentelemetry::Request::Metrics.new(msg).body
-          when Opentelemetry::RECORD_TYPE_TRACES
-            uri = http_traces_endpoint
-            body = Opentelemetry::Request::Traces.new(msg).body
-          end
-        rescue Google::Protobuf::ParseError => e
-          # The message format does not comply with the OpenTelemetry protocol.
-          raise ::Fluent::UnrecoverableError, e.message
-        end
-
-        headers = { Opentelemetry::CONTENT_TYPE => Opentelemetry::CONTENT_TYPE_PROTOBUF }
-        if @http_config.compress == :gzip
-          headers[Opentelemetry::CONTENT_ENCODING] = Opentelemetry::CONTENT_ENCODING_GZIP
-          gz = Zlib::GzipWriter.new(StringIO.new)
-          gz << body
-          body = gz.close.string
-        end
-
-        Excon.defaults[:ssl_verify_peer] = false if @transport_config.insecure
-        connection = Excon.new(uri, body: body, headers: headers, proxy: @http_config.proxy, persistent: true, **@tls_settings, **@timeout_settings)
-        [uri, connection]
-      end
-    end
-
-    class GrpcHandler
-      def initialize(grpc_config, transport_config, logger)
-        @grpc_config = grpc_config
-        @transport_config = transport_config
-        @logger = logger
-      end
-
-      def export(record)
-        msg = record["message"]
-
-        credential = :this_channel_is_insecure
-
-        case record["type"]
-        when Opentelemetry::RECORD_TYPE_LOGS
-          service = Opentelemetry::ServiceStub::Logs.new(@grpc_config.endpoint, credential)
-        when Opentelemetry::RECORD_TYPE_METRICS
-          service = Opentelemetry::ServiceStub::Metrics.new(@grpc_config.endpoint, credential)
-        when Opentelemetry::RECORD_TYPE_TRACES
-          service = Opentelemetry::ServiceStub::Traces.new(@grpc_config.endpoint, credential)
-        end
-
-        begin
-          service.export(msg)
-        rescue Google::Protobuf::ParseError => e
-          # The message format does not comply with the OpenTelemetry protocol.
-          raise ::Fluent::UnrecoverableError, e.message
-        end
-      end
-    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-opentelemetry
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Shizuo Fujita
@@ -65,20 +65,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.30'
-- !ruby/object:Gem::Dependency
-  name: grpc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.71'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.71'
 description: Fluentd input/output plugin to forward OpenTelemetry Protocol data.
 email:
 - fujita@clear-code.com
@@ -94,10 +80,12 @@ files:
 - TODO.md
 - lib/fluent/plugin/in_opentelemetry.rb
 - lib/fluent/plugin/opentelemetry/constant.rb
+- lib/fluent/plugin/opentelemetry/grpc_input_handler.rb
+- lib/fluent/plugin/opentelemetry/grpc_output_handler.rb
+- lib/fluent/plugin/opentelemetry/http_input_handler.rb
+- lib/fluent/plugin/opentelemetry/http_output_handler.rb
 - lib/fluent/plugin/opentelemetry/request.rb
 - lib/fluent/plugin/opentelemetry/response.rb
-- lib/fluent/plugin/opentelemetry/service_handler.rb
-- lib/fluent/plugin/opentelemetry/service_stub.rb
 - lib/fluent/plugin/out_opentelemetry.rb
 - lib/opentelemetry/proto/collector/logs/v1/logs_service_pb.rb
 - lib/opentelemetry/proto/collector/logs/v1/logs_service_services_pb.rb
@@ -134,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.7.0
 specification_version: 4
 summary: Fluentd input/output plugin to forward OpenTelemetry Protocol data.
 test_files: []

data/lib/fluent/plugin/opentelemetry/service_handler.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "opentelemetry/proto/collector/logs/v1/logs_service_services_pb"
-require "opentelemetry/proto/collector/metrics/v1/metrics_service_services_pb"
-require "opentelemetry/proto/collector/trace/v1/trace_service_services_pb"
-
-class Fluent::Plugin::Opentelemetry::ServiceHandler
-  class Logs < Opentelemetry::Proto::Collector::Logs::V1::LogsService::Service
-    def callback=(block)
-      @callback = block
-    end
-
-    def export(req, _call)
-      @callback.call(req)
-    end
-  end
-
-  class Metrics < Opentelemetry::Proto::Collector::Metrics::V1::MetricsService::Service
-    def callback=(block)
-      @callback = block
-    end
-
-    def export(req, _call)
-      @callback.call(req)
-    end
-  end
-
-  class Traces < Opentelemetry::Proto::Collector::Trace::V1::TraceService::Service
-    def callback=(block)
-      @callback = block
-    end
-
-    def export(req, _call)
-      @callback.call(req)
-    end
-  end
-end

data/lib/fluent/plugin/opentelemetry/service_stub.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "opentelemetry/proto/collector/logs/v1/logs_service_pb"
-require "opentelemetry/proto/collector/logs/v1/logs_service_services_pb"
-require "opentelemetry/proto/collector/metrics/v1/metrics_service_pb"
-require "opentelemetry/proto/collector/metrics/v1/metrics_service_services_pb"
-require "opentelemetry/proto/collector/trace/v1/trace_service_pb"
-require "opentelemetry/proto/collector/trace/v1/trace_service_services_pb"
-
-require "grpc"
-
-class Fluent::Plugin::Opentelemetry::ServiceStub
-  class Logs
-    def initialize(host, creds, **kw)
-      @stub = Opentelemetry::Proto::Collector::Logs::V1::LogsService::Stub.new(host, creds, **kw)
-    end
-
-    def export(json)
-      message = Opentelemetry::Proto::Collector::Logs::V1::ExportLogsServiceRequest.decode_json(json)
-      @stub.export(message)
-    end
-  end
-
-  class Metrics
-    def initialize(host, creds, **kw)
-      @stub = Opentelemetry::Proto::Collector::Metrics::V1::MetricsService::Stub.new(host, creds, **kw)
-    end
-
-    def export(json)
-      message = Opentelemetry::Proto::Collector::Metrics::V1::ExportMetricsServiceRequest.decode_json(json)
-      @stub.export(message)
-    end
-  end
-
-  class Traces
-    def initialize(host, creds, **kw)
-      @stub = Opentelemetry::Proto::Collector::Trace::V1::TraceService::Stub.new(host, creds, **kw)
-    end
-
-    def export(json)
-      message = Opentelemetry::Proto::Collector::Trace::V1::ExportTraceServiceRequest.decode_json(json)
-      @stub.export(message)
-    end
-  end
-end