grpc_interceptors 0.1.4 → 0.2.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d25e64c56db11d1b34fd966a59da4ad97ca2883fdbb68f2e046731a0f46f538
-  data.tar.gz: 282ee4ba2bf4dafe62c5896697106c48e26e8d739ff62dc3f603bddbeba37049
+  metadata.gz: '0299aaae1513e603f87075759a05a21f189261de4148ff7011d9e1185800e16b'
+  data.tar.gz: fe5c8bc7c0b3b6d08c753cde51c2c9e7364e38412ce0f9e14f1c1de43cdea2e5
 SHA512:
-  metadata.gz: c28c9eb7f8e08408a243ed15c400203165466c1c128f7552c97c12b87c996790c6a9c99751d011cb2cb317bdc9a62153f81fd86abbfba7601745a0ba8ab95878
-  data.tar.gz: 33279a6a49e2414e50e70a621fd5a1584ce87c06de408395e05f9442c5b4d4100a45e86aa589feee9083afffb1415b1d4979a94b218b45318f50c0be7ae2749f
+  metadata.gz: 32b8cb86b89c5ef463c1509e222531187af223e84f7784782689648d0d0a47084e78fa9041f441cc1ade9d3d70cce827900070867c255b7b8d68386b872bd0e4
+  data.tar.gz: d5ebfebd144ae7b2dc7d57fa1d4041308652ae6f6bc40e8b519acc3eb4d3fdc3f2df25f980f9d75357c058af649192e1a7aa45d535c8572716dfe4ac78cdb58b

data/lib/grpc_interceptors/client/logging_interceptor.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../common/grpc_helper'
+require_relative '../common/logging'
+
+module GrpcInterceptors
+  module Client
+    class LoggingInterceptor < ::GRPC::ClientInterceptor
+      def initialize(logger)
+        @logger = logger
+
+        super()
+      end
+
+      def request_response(
+        request: nil, call: nil, method: nil, metadata: nil, &block
+      )
+        Common::Logging.yield_and_log(
+          logger: @logger, request: request, method: method,
+          method_type: 'unary', kind: KIND, &block
+        )
+      end
+
+      def client_streamer(
+        requests: nil, call: nil, method: nil, metadata: nil, &block
+      )
+        requests.each do |request|
+          Common::Logging.log(request: request, method: method, method_type: 'client_stream')
+        end
+
+        Common::Logging.yield_and_log(method: method, method_type: 'client_stream', &block)
+      end
+
+      def server_streamer(
+        request: nil, call: nil, method: nil, metadata: nil, &block
+      )
+        Common::Logging.yield_and_log(
+          logger: @logger, request: request, method: method,
+          method_type: 'server_stream', kind: KIND, &block
+        )
+      end
+
+      # def bidi_streamer(_requests: nil, call: nil, method: nil, metadata: nil)
+      #  yield
+      # end
+    end
+  end
+end

data/lib/grpc_interceptors/client/{opentelemetry_tracing_instrument.rb → opentelemetry_tracing_interceptor.rb}

@@ -5,13 +5,12 @@ require_relative '../common/opentelemetry_helper'
 
 module GrpcInterceptors
   module Client
-    class OpenTelemetryTracingInstrument < ::GRPC::ClientInterceptor
+    class OpenTelemetryTracingInterceptor < ::GRPC::ClientInterceptor
       def request_response(request: nil, call: nil, method: nil, metadata: nil)
-        kind = OpenTelemetry::Trace::SpanKind::CLIENT
         attributes = Common::OpenTelemetryHelper.tracing_attributes(method)
 
         Common::OpenTelemetryHelper.tracer.in_span(
-          method, kind: kind, attributes: attributes
+          method, kind: KIND, attributes: attributes
         ) do
           OpenTelemetry.propagation.inject(metadata)
           yield
@@ -22,9 +21,16 @@ module GrpcInterceptors
       #  yield
       # end
 
-      # def server_streamer(_request: nil, call: nil, method: nil, metadata: nil)
-      #   yield
-      # end
+      def server_streamer(request: nil, call: nil, method: nil, metadata: nil)
+        attributes = Common::OpenTelemetryHelper.tracing_attributes(method)
+
+        Common::OpenTelemetryHelper.tracer.in_span(
+          method, kind: KIND, attributes: attributes
+        ) do
+          OpenTelemetry.propagation.inject(metadata)
+          yield
+        end
+      end
 
       # def bidi_streamer(_requests: nil, call: nil, method: nil, metadata: nil)
       # yield

data/lib/grpc_interceptors/client.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module GrpcInterceptors
+  module Client
+    KIND = :client
+  end
+end

data/lib/grpc_interceptors/common/grpc_helper.rb

@@ -42,6 +42,19 @@ module GrpcInterceptors
         method_parts = method.to_s.sub(%r{^/}, '').split('/')
         method_parts[1..].join('/')
       end
+
+      # converts proto message to a Ruby hash preserving the original fields' names
+      # and including default values
+      # WARNING! It can be slow and not 100% accurate. In this gem it's only used in the DEBUG mode
+      # related comment: https://github.com/protocolbuffers/protobuf/issues/6755#issuecomment-733880977
+      def self.proto_to_h(proto)
+        JSON(
+          proto.to_json(
+            emit_defaults: true,
+            preserve_proto_fieldnames: true
+          )
+        )
+      end
     end
   end
 end

data/lib/grpc_interceptors/common/log_payload.rb

@@ -2,8 +2,50 @@
 
 module GrpcInterceptors
   module Common
-    module LogPayload
-      def self.build(method, method_type, grpc_code, kind)
+    module Logger
+      ##
+      # Log a gRPC interaction from the client side.
+      #
+      # If the current log level is INFO, then it logs out basic facts.
+      # If the current log level is DEBUG, then it additionally adds to the log request and response.
+      # If the server responds with error, then the error is added to the log.
+      #
+      # @param [Object] request The request object
+      # @param [String] method The method passed to the intercepting function
+      # @param [String] method_type The used method_type, unary or one of the streams
+      #
+      def self.log(
+        logger: nil, request: nil, method: nil, method_type: nil, kind: nil
+      )
+        payload = build_payload(method, method_type, kind)
+
+        if block_given?
+          grpc_code = ::GRPC::Core::StatusCodes::OK
+          begin
+            response = yield
+          rescue StandardError => e
+            grpc_code = e.is_a?(::GRPC::BadStatus) ? e.code : ::GRPC::Core::StatusCodes::UNKNOWN
+
+            payload['error'] = e.class.to_s
+            payload['error_message'] = e.message
+            payload['backtrace'] = e.backtrace
+
+            raise
+          end
+        end
+      ensure
+        payload['grpc_code'] = grpc_code unless grpc_code.nil?
+
+        if logger.level == Logger::Severity::INFO
+          logger.info(payload)
+        elsif logger.level == Logger::Severity::DEBUG
+          payload['request'] = Common::GrpcHelper.proto_to_h(request) unless request.nil?
+          payload['response'] = Common::GrpcHelper.proto_to_h(response) unless response.nil?
+          logger.debug(payload)
+        end
+      end
+
+      def self.build_payload(method, method_type, kind)
         service = GrpcHelper.service_name(method)
         method = GrpcHelper.method_name(method)
 
@@ -12,8 +54,7 @@ module GrpcInterceptors
           'grpc.component' => kind, # the caller, server or client
           'grpc.service' => service,
           'grpc.method' => method,
-          'grpc.method_type' => method_type,
-          'grpc.code' => grpc_code
+          'grpc.method_type' => method_type
         }
 
         if defined?(OpenTelemetry) && OpenTelemetry::Trace.current_span.recording?

data/lib/grpc_interceptors/common/logging.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module GrpcInterceptors
+  module Common
+    module Logging
+      def self.yield_and_log(
+        logger: nil, request: nil, method: nil, method_type: nil, kind: nil
+      )
+        grpc_code = ::GRPC::Core::StatusCodes::OK
+        response = yield
+      rescue StandardError => e
+        grpc_code = e.is_a?(::GRPC::BadStatus) ? e.code : ::GRPC::Core::StatusCodes::UNKNOWN
+        extra_fields = {
+          'error' => e.class.to_s,
+          'error_message' => e.message,
+          'backtrace' => e.backtrace
+        }
+
+        raise
+      ensure
+        extra_fields ||= {}
+        extra_fields['grpc.code'] = grpc_code
+
+        if logger.level == ::Logger::Severity::DEBUG && !response.nil? && !response.is_a?(Enumerator)
+          extra_fields['response'] = Common::GrpcHelper.proto_to_h(response)
+        end
+
+        log(
+          logger: logger, request: request, method: method,
+          method_type: method_type, kind: kind, extra_fields: extra_fields
+        )
+      end
+
+      ##
+      # Log a gRPC interaction.
+      #
+      # If the current log level is INFO, then it logs out basic facts.
+      # If the current log level is DEBUG, then it additionally adds to the log request and response.
+      # If the server responds with error, then the error is added to the log.
+      #
+      # @param [Object] request The request object
+      # @param [String] method The method passed to the intercepting function
+      # @param [String] method_type The used method_type, unary or one of the streams
+      #
+      def self.log(
+        logger: nil, request: nil, method: nil, method_type: nil, kind: nil,
+        extra_fields: {}
+      )
+        payload = build_payload(method, method_type, kind)
+        payload.merge!(extra_fields)
+
+        if logger.level == ::Logger::Severity::INFO
+          logger.info(payload)
+        elsif logger.level == ::Logger::Severity::DEBUG
+          payload['request'] = Common::GrpcHelper.proto_to_h(request) unless request.nil?
+          logger.debug(payload)
+        end
+      end
+
+      def self.build_payload(method, method_type, kind)
+        service = GrpcHelper.service_name(method)
+        method = GrpcHelper.method_name(method)
+
+        payload = {
+          'pid' => Process.pid,
+          'grpc.component' => kind, # the caller, server or client
+          'grpc.service' => service,
+          'grpc.method' => method,
+          'grpc.method_type' => method_type
+        }
+
+        if defined?(OpenTelemetry) && OpenTelemetry::Trace.current_span.recording?
+          tracing_context = OpenTelemetry::Trace.current_span.context
+          payload['span_id'] = tracing_context.hex_span_id
+          payload['trace_id'] = tracing_context.hex_trace_id
+        end
+
+        payload
+      end
+    end
+  end
+end

data/lib/grpc_interceptors/server/logging_interceptor.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../common/grpc_helper'
+require_relative '../common/logging'
+
+module GrpcInterceptors
+  module Server
+    class LoggingInterceptor < ::GRPC::ServerInterceptor
+      def initialize(logger)
+        @logger = logger
+
+        super()
+      end
+
+      def request_response(request: nil, call: nil, method: nil, &block)
+        Common::Logging.yield_and_log(
+          logger: @logger, request: request, method: method,
+          method_type: 'unary', kind: KIND, &block
+        )
+      end
+
+      # def client_streamer(call: nil, method: nil)
+      #  yield
+      # end
+
+      # def server_streamer(_request: nil, call: nil, method: nil)
+      #  yield
+      # end
+
+      # def bidi_streamer(_requests: nil, call: nil, method: nil)
+      #  yield
+      # end
+    end
+  end
+end

data/lib/grpc_interceptors/server/{opentelemetry_tracing_instrument.rb → opentelemetry_tracing_interceptor.rb}

@@ -6,18 +6,17 @@ require_relative '../common/opentelemetry_helper'
 module GrpcInterceptors
   module Server
     # https://github.com/grpc/grpc/blob/master/src/ruby/lib/grpc/generic/interceptors.rb
-    class OpenTelemetryTracingInstrument < ::GRPC::ServerInterceptor
+    class OpenTelemetryTracingInterceptor < ::GRPC::ServerInterceptor
       def request_response(request: nil, call: nil, method: nil, &block)
         context = OpenTelemetry.propagation.extract(call.metadata)
         route_name = Common::GrpcHelper.route_name(method)
         attributes = Common::OpenTelemetryHelper.tracing_attributes(method)
-        kind = OpenTelemetry::Trace::SpanKind::SERVER
 
         OpenTelemetry::Context.with_current(context) do
           Common::OpenTelemetryHelper.tracer.in_span(
             route_name,
             attributes: attributes,
-            kind: kind,
+            kind: KIND,
             &block
           )
         end

data/lib/grpc_interceptors/server.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module GrpcInterceptors
+  module Server
+    KIND = :server
+  end
+end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: grpc_interceptors
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0.rc1
 platform: ruby
 authors:
 - michal-kazmierczak
-autorequire:
+- andykimchris
 bindir: bin
 cert_chain: []
-date: 2024-03-06 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grpc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.61'
+        version: '1.67'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.61'
+        version: '1.67'
 - !ruby/object:Gem::Dependency
   name: grpc-tools
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.61'
+        version: '1.67'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.61'
+        version: '1.67'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
@@ -236,7 +236,6 @@ dependencies:
         version: '3.6'
 description: A collection of Ruby interceptors (middlewares) for gRPC servers and
   clients.
-email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -244,13 +243,16 @@ files:
 - LICENSE
 - README.md
 - lib/grpc_interceptors.rb
-- lib/grpc_interceptors/client/logging.rb
-- lib/grpc_interceptors/client/opentelemetry_tracing_instrument.rb
+- lib/grpc_interceptors/client.rb
+- lib/grpc_interceptors/client/logging_interceptor.rb
+- lib/grpc_interceptors/client/opentelemetry_tracing_interceptor.rb
 - lib/grpc_interceptors/common/grpc_helper.rb
 - lib/grpc_interceptors/common/log_payload.rb
+- lib/grpc_interceptors/common/logging.rb
 - lib/grpc_interceptors/common/opentelemetry_helper.rb
-- lib/grpc_interceptors/server/logging.rb
-- lib/grpc_interceptors/server/opentelemetry_tracing_instrument.rb
+- lib/grpc_interceptors/server.rb
+- lib/grpc_interceptors/server/logging_interceptor.rb
+- lib/grpc_interceptors/server/opentelemetry_tracing_interceptor.rb
 - lib/grpc_interceptors/server/statsd_metrics.rb
 homepage: https://github.com/michal-kazmierczak/ruby-grpc-interceptors
 licenses:
@@ -258,7 +260,6 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -273,8 +274,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A collection of Ruby interceptors (middlewares) for gRPC servers and clients.
 test_files: []

data/lib/grpc_interceptors/client/logging.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../common/grpc_helper'
-require_relative '../common/log_payload'
-
-module GrpcInterceptors
-  module Client
-    class Logging < ::GRPC::ServerInterceptor
-      def initialize(logger)
-        @logger = logger
-
-        super()
-      end
-
-      def request_response(
-        request: nil, call: nil, method: nil, metadata: nil, &block
-      )
-        log(request, method, 'unary', &block)
-      end
-
-      # def client_streamer(_requests: nil, call: nil, method: nil, metadata: nil)
-      #  yield
-      # end
-
-      # def server_streamer(_request: nil, call: nil, method: nil, metadata: nil)
-      #  yield
-      # end
-
-      # def bidi_streamer(_requests: nil, call: nil, method: nil, metadata: nil)
-      #  yield
-      # end
-
-      private
-
-      # if the server responds with error, then the error is attached to the log
-      # if the current level is INFO, then it logs out basic facts
-      # if the current level is DEBUG, then it additionally includes the request
-      def log(request, method, method_type)
-        grpc_code = ::GRPC::Core::StatusCodes::OK
-
-        response = yield
-      rescue StandardError => e
-        grpc_code = e.is_a?(::GRPC::BadStatus) ? e.code : ::GRPC::Core::StatusCodes::UNKNOWN
-
-        raise
-      ensure
-        payload = Common::LogPayload.build(
-          method, method_type, grpc_code, 'client'
-        )
-
-        if e
-          payload['error'] = e.class.to_s
-          payload['error_message'] = e.message
-          payload['backtrace'] = e.backtrace
-        end
-
-        if @logger.level == Logger::Severity::INFO
-          @logger.info(payload)
-        elsif @logger.level == Logger::Severity::DEBUG
-          payload['request'] = request.to_h
-          payload['response'] = response.to_h
-          @logger.debug(payload)
-        end
-      end
-    end
-  end
-end

data/lib/grpc_interceptors/server/logging.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../common/grpc_helper'
-require_relative '../common/log_payload'
-
-module GrpcInterceptors
-  module Server
-    class Logging < ::GRPC::ServerInterceptor
-      def initialize(logger)
-        @logger = logger
-
-        super()
-      end
-
-      def request_response(request: nil, call: nil, method: nil, &block)
-        log(request, method, 'unary', &block)
-      end
-
-      # def client_streamer(call: nil, method: nil)
-      #  yield
-      # end
-
-      # def server_streamer(_request: nil, call: nil, method: nil)
-      #  yield
-      # end
-
-      # def bidi_streamer(_requests: nil, call: nil, method: nil)
-      #  yield
-      # end
-
-      private
-
-      # in case of an exception, it logs out on the ERROR level including error details
-      # if the current level is INFO, then it logs out basic facts
-      # if the current level is DEBUG, then it additionally includes the request
-      def log(request, method, method_type)
-        grpc_code = ::GRPC::Core::StatusCodes::OK
-
-        yield
-      rescue StandardError => e
-        grpc_code = e.is_a?(::GRPC::BadStatus) ? e.code : ::GRPC::Core::StatusCodes::UNKNOWN
-
-        raise
-      ensure
-        payload = Common::LogPayload.build(
-          method, method_type, grpc_code, 'server'
-        )
-
-        if e
-          payload['error'] = e.class.to_s
-          payload['error_message'] = e.message
-          payload['backtrace'] = e.backtrace
-          @logger.error(payload)
-        elsif @logger.level == Logger::Severity::INFO
-          @logger.info(payload)
-        elsif @logger.level == Logger::Severity::DEBUG
-          payload['request'] = request.to_h
-          @logger.debug(payload)
-        end
-      end
-    end
-  end
-end