multiplayer_otlp 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7eeb6ab03f33e4743bfebca755ccbceda2cd5d4ab6845b8253efd76959c56a1e
+  data.tar.gz: 0fb380313170e64a5e13973458fe4ffefb719e5f241f6ed91db5d5b5bae0c657
+SHA512:
+  metadata.gz: 5cfefcca13d72d096f0b1b58030cfaa20a8a9c3733137662b49a56f3e4b56ba4c312e3807f9d5035b9cfcd87749790316e12f455e6e9fda896cc5d6c3fefce1d
+  data.tar.gz: 3d8361914b09d0279f60055fac13fbad994100dbe933f381362029695c4c2defbef599561c4157a6cb1c25004749fec405309e9d390daaa9ca45219056e97236

data/lib/multiplayer/exporters/http_exporter.rb

@@ -0,0 +1,57 @@
+require "json"
+require "opentelemetry/sdk"
+require "opentelemetry/exporter/otlp"
+
+module Multiplayer
+  class ExporterConfig
+    attr_accessor :endpoint, :headers, :api_key
+
+    def initialize(endpoint: nil, headers: {}, api_key: nil)
+      @endpoint = endpoint
+      @headers = headers
+      @api_key = api_key
+    end
+  end
+
+  class Exporter < OpenTelemetry::Exporter::OTLP::Exporter
+    def initialize(config = Multiplayer::ExporterConfig.new)
+
+      config.endpoint ||= MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_URL
+      config.headers = (config.headers || {}).merge(
+        config.api_key ? { "Authorization" => config.api_key } : {}
+      )
+      super(endpoint: config.endpoint, headers: config.headers)
+    end
+
+    def get_default_url(config)
+      config.url || MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_URL
+    end
+
+    def self.filter_mp_attributes(exporter)
+      original_export = exporter.method("export")
+      exporter.define_singleton_method("export") do |*args, &block|
+        args[0] = Exporter.prefilter(args[0])
+        original_export.call(*args, &block)
+      end
+
+      exporter
+    end
+
+    private
+    def self.prefilter(spans)
+      spans.map do |span|
+        new_attributes = span[:attributes].each_with_object({}) do |(key, value), acc|
+          unless key.start_with?(MULTIPLAYER_ATTRIBUTE_PREFIX)
+            acc[key] = value
+          end
+        end
+
+        span_with_new_attributes = span.dup
+        span_with_new_attributes[:attributes] = new_attributes
+
+        span_with_new_attributes
+      end
+    end
+
+  end
+end

data/lib/multiplayer/middleware/middleware.rb

@@ -0,0 +1,122 @@
+require "json"
+
+module Multiplayer
+  class Middleware
+    attr_reader :headers_to_mask, :max_payload_size, :schemify_doc_span_payload, :mask_deb_span_payload
+    def initialize(app, options = {
+          headers_to_mask: [],
+          max_payload_size: nil,
+          schemify_doc_span_payload: true,
+          mask_deb_span_payload: true
+        }
+    )
+      @app = app
+      @headers_to_mask = options[:headers_to_mask] || []
+      @max_payload_size = options[:max_payload_size] || MULTIPLAYER_MAX_HTTP_REQUEST_RESPONSE_SIZE
+      @schemify_doc_span_payload = options.key?(:schemify_doc_span_payload) ?
+                                     options[:schemify_doc_span_payload] :
+                                     true
+      @mask_deb_span_payload = options.key?(:mask_deb_span_payload) ?
+                                 options[:mask_deb_span_payload] :
+                                 true
+
+      if @max_payload_size > MULTIPLAYER_MAX_HTTP_REQUEST_RESPONSE_SIZE
+        @max_payload_size = MULTIPLAYER_MAX_HTTP_REQUEST_RESPONSE_SIZE
+      end
+    end
+
+    protected
+
+    def mask_primitives(input, current_depth = 0)
+      return MASK_PLACEHOLDER if current_depth >= MAX_MASK_DEPTH
+
+      case input
+      when Hash
+        input.transform_values { |value| mask_primitives(value, current_depth + 1) }
+      when Array
+        input.map { |value| mask_primitives(value, current_depth + 1) }
+      when String, Numeric, TrueClass, FalseClass, NilClass, Symbol
+        MASK_PLACEHOLDER
+      else
+        input
+      end
+    end
+
+    def mask_body(value)
+      payload_json = begin
+                       JSON.parse(value)
+                     rescue JSON::ParserError
+                       value
+                     end
+
+      masked_data = mask_primitives(payload_json)
+
+      unless masked_data.is_a?(String)
+        masked_data = masked_data.to_json
+      end
+
+      masked_data
+    end
+
+    def schemify(payload)
+      return "" if payload.nil?
+      payload_json = nil
+
+      if payload.is_a?(String)
+        begin
+          payload_json = JSON.parse(payload)
+        rescue JSON::ParserError
+          return payload
+        end
+      elsif payload.is_a?(Hash) || payload.is_a?(Array)
+        payload_json = payload
+      else
+        return payload
+      end
+
+      begin
+        Multiplayer::Utils::JsonSchemaGenerator.generate(payload_json)
+      rescue StandardError => exception
+        ""
+      end
+    end
+
+    def mask_headers(headers, custom_header_names_to_mask = [])
+      default_header_names_to_mask = ["set-cookie", "cookie", "authorization", "proxy-authorization"]
+      masked_headers = headers.dup
+      headers_to_mask = default_header_names_to_mask + custom_header_names_to_mask
+
+      headers_to_mask.each do |header_name|
+        masked_headers[header_name] = MASK_PLACEHOLDER if masked_headers.key?(header_name)
+      end
+
+      masked_headers
+    end
+
+
+    # Extracts request headers from the Rack environment
+    def extract_request_headers(env)
+      env.select { |k, _| k.start_with?("HTTP_") }
+         .transform_keys { |k| k.sub(/^HTTP_/, "").split("_").map(&:downcase).join("-") }
+    end
+
+    # Reads the request body safely
+    def extract_request_body(request)
+      body = request.body.read
+      request.body.rewind # Rewind the stream for downstream middlewares
+    end
+
+    # Reads the response body safely
+    def extract_response_body(response)
+      body = []
+      response.each { |part| body << part }
+      body.join
+    end
+
+    # Truncates payload if maxPayloadSize is set
+    def truncate_if_needed(data)
+      return data unless data.to_s.size > @max_payload_size
+      "#{data[0...@max_payload_size]}...[TRUNCATED]"
+    end
+  end
+end

data/lib/multiplayer/middleware/request_middleware.rb

@@ -0,0 +1,31 @@
+module Multiplayer
+  class RequestMiddleware < Multiplayer::Middleware
+    def call(env)
+      current_span = OpenTelemetry::Trace.current_span
+      trace_id = current_span.context.trace_id.unpack1("H*")
+      request = Rack::Request.new(env)
+
+      request_headers = extract_request_headers(env)
+      masked_headers = mask_headers(request_headers, @headers_to_mask)
+      current_span.set_attribute(ATTR_MULTIPLAYER_HTTP_REQUEST_HEADERS, masked_headers.to_json)
+
+      if request_headers.key?("content-type")  == "application/json"
+        request_body = (extract_request_body(request)).dup
+
+        if trace_id.start_with?(MULTIPLAYER_TRACE_DEBUG_PREFIX) && @mask_deb_span_payload
+          request_body = mask_body(request_body)
+        elsif trace_id.start_with?(MULTIPLAYER_TRACE_DOC_PREFIX) || @schemify_doc_span_payload
+          request_body = schemify(request_body)
+        elsif !request_body.is_a?(String)
+          request_body = JSON.generate(request_body)
+        end
+
+        request_body = truncate_if_needed(request_body)
+
+        current_span.set_attribute(ATTR_MULTIPLAYER_HTTP_REQUEST_BODY, request_body.is_a?(String) ? request_body : request_body.to_json)
+      end
+
+      @app.call(env)
+    end
+  end
+end

data/lib/multiplayer/middleware/response_middleware.rb

@@ -0,0 +1,32 @@
+module Multiplayer
+  class ResponseMiddleware < Multiplayer::Middleware
+    def call(env)
+      status, headers, response = @app.call(env)
+
+      begin
+        current_span = OpenTelemetry::Trace.current_span
+        trace_id = current_span.context.trace_id.unpack1("H*")
+
+        headers["x-trace-id"] = trace_id
+
+        masked_headers = mask_headers(headers, @headers_to_mask)
+        response_body = (extract_response_body(response)).dup
+
+        if trace_id.start_with?(MULTIPLAYER_TRACE_DEBUG_PREFIX) && @mask_deb_span_payload
+          response_body = mask_body(response_body)
+        elsif trace_id.start_with?(MULTIPLAYER_TRACE_DOC_PREFIX) || @schemify_doc_span_payload
+          response_body = schemify(response_body)
+        elsif !response_body.is_a?(String)
+          response_body = JSON.generate(response_body)
+        end
+        response_body = truncate_if_needed(response_body)
+
+        current_span.set_attribute(ATTR_MULTIPLAYER_HTTP_RESPONSE_HEADERS, masked_headers.to_json)
+        current_span.set_attribute(ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY, response_body.is_a?(String) ? response_body : response_body.to_json)
+        [ status, headers, response ]
+      rescue
+        [ status, headers, response ]
+      end
+    end
+  end
+end

data/lib/multiplayer/multiplayer.rb

@@ -0,0 +1,25 @@
+require_relative "utils/id_generator"
+require_relative "utils/json_schema_generator"
+require_relative "utils/trace_id_ratio_based_sampler"
+require_relative "version"
+require_relative "exporters/http_exporter"
+require_relative "middleware/middleware"
+require_relative "middleware/request_middleware"
+require_relative "middleware/response_middleware"
+
+module Multiplayer
+  MULTIPLAYER_TRACE_DOC_PREFIX = "d0cd0c"
+  MULTIPLAYER_TRACE_DEBUG_PREFIX = "debdeb"
+  MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_URL = "https://api.multiplayer.app/v1/traces"
+  MULTIPLAYER_OTEL_DEFAULT_LOGS_EXPORTER_URL = "https://api.multiplayer.app/v1/logs"
+  MULTIPLAYER_ATTRIBUTE_PREFIX = "multiplayer."
+  MULTIPLAYER_MAX_HTTP_REQUEST_RESPONSE_SIZE = (ENV["MULTIPLAYER_MAX_HTTP_REQUEST_RESPONSE_SIZE"] || "500000").to_i
+  ATTR_MULTIPLAYER_DEBUG_SESSION = "multiplayer.debug_session._id"
+  ATTR_MULTIPLAYER_HTTP_REQUEST_BODY = "multiplayer.http.request.body"
+  ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY = "multiplayer.http.response.body"
+  ATTR_MULTIPLAYER_HTTP_REQUEST_HEADERS = "multiplayer.http.request.headers"
+  ATTR_MULTIPLAYER_HTTP_RESPONSE_HEADERS = "multiplayer.http.response.headers"
+  ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY_ENCODING = "multiplayer.http.response.body.encoding"
+  MASK_PLACEHOLDER = "***MASKED***"
+  MAX_MASK_DEPTH = 8
+end

data/lib/multiplayer/utils/id_generator.rb

@@ -0,0 +1,42 @@
+require "opentelemetry-sdk"
+
+module Multiplayer
+  module Utils
+    class IdGenerator
+      include OpenTelemetry::Trace
+      attr_accessor :debug_session_short_id, :id_generator, :sampler
+
+      SHARED_CHAR_CODES_ARRAY = Array.new(32)
+
+      def initialize(auto_doc_traces_ratio = 0)
+        @debug_session_short_id = nil
+        @id_generator = IdGenerator.get_id_generator(16)
+        @sampler = TraceIdRatioBasedSampler.new(auto_doc_traces_ratio)
+      end
+
+      def generate_trace_id
+        trace_id = @id_generator.call
+        if @debug_session_short_id
+          prefix = "#{MULTIPLAYER_TRACE_DEBUG_PREFIX}#{@debug_session_short_id}"
+          trace_id = "#{prefix}#{trace_id[prefix.length..-1]}"
+        elsif @sampler.is_mp_trace_id?(trace_id)
+          trace_id = "#{MULTIPLAYER_TRACE_DOC_PREFIX}#{trace_id[MULTIPLAYER_TRACE_DOC_PREFIX.length..-1]}"
+        end
+        [ trace_id ].pack("H*")
+      end
+
+      def self.get_id_generator(bytes)
+        lambda do
+          (0...(bytes * 2)).each do |i|
+            SHARED_CHAR_CODES_ARRAY[i] = rand(16) + 48
+            # valid hex characters in the range 48-57 and 97-102
+            if SHARED_CHAR_CODES_ARRAY[i] >= 58
+              SHARED_CHAR_CODES_ARRAY[i] += 39
+            end
+          end
+          SHARED_CHAR_CODES_ARRAY[0...(bytes * 2)].map(&:chr).join
+        end
+      end
+    end
+  end
+end

data/lib/multiplayer/utils/json_schema_generator.rb

@@ -0,0 +1,36 @@
+require "json-schema-generator"
+
+module Multiplayer
+  module Utils
+    class JsonSchemaGenerator < JSON::SchemaGenerator
+      class << self
+        def generate(data)
+          generator = Multiplayer::JsonSchemaGenerator.new
+          generator.generate data
+        end
+      end
+
+      def initialize
+        @version = DRAFT4
+        @defaults = nil
+
+        @buffer = StringIO.new
+      end
+
+      def generate(data)
+        statement_group = StatementGroup.new
+        case data
+        when Array
+          $stop = true
+          create_array(statement_group, data, [])
+        when Hash
+          create_hash(statement_group, data, [])
+        else
+          create_primitive(statement_group, "", data, [])
+        end
+        @buffer.puts statement_group
+        result
+      end
+    end
+  end
+end

data/lib/multiplayer/utils/trace_id_ratio_based_sampler.rb

@@ -0,0 +1,57 @@
+require "opentelemetry-sdk"
+
+module Multiplayer
+  module Utils
+    class TraceIdRatioBasedSampler < OpenTelemetry::SDK::Trace::Samplers::TraceIdRatioBased
+      def initialize(ratio = 0)
+        @ratio = normalize(ratio)
+        @upper_bound = (@ratio * 0xffffffff).floor
+        super(@ratio)
+      end
+
+      def should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:)
+        tracestate = OpenTelemetry::Trace.current_span(parent_context).context.tracestate
+        if self.is_mp_trace_id?(trace_id.unpack1("H*"))
+          OpenTelemetry::SDK::Trace::Samplers::Result.new(decision: OpenTelemetry::SDK::Trace::Samplers::Decision::RECORD_AND_SAMPLE, tracestate: tracestate)
+        else
+          OpenTelemetry::SDK::Trace::Samplers::Result.new(decision: OpenTelemetry::SDK::Trace::Samplers::Decision::DROP, tracestate: tracestate)
+        end
+      end
+
+      def is_mp_trace_id?(trace_id)
+        trace_id.start_with?(MULTIPLAYER_TRACE_DEBUG_PREFIX) ||
+          trace_id.start_with?(MULTIPLAYER_TRACE_DOC_PREFIX) ||
+          (self.valid_trace_id?(trace_id) && self.accumulate(trace_id) < @upper_bound)
+      end
+
+      def description
+        "MultiplayerTraceIdRatioBasedSampler#{@ratio}"
+      end
+
+      private
+
+      def valid_trace_id?(trace_id)
+        trace_id.is_a?(String) && trace_id.length == 32 && trace_id =~ /^([0-9a-f]{32})$/i
+      end
+
+      def normalize(ratio)
+        return 0 unless defined?(ratio) && ratio.is_a?(Numeric)
+        return 1 if ratio >= 1
+        return 0 if ratio <= 0
+
+        ratio
+      end
+
+      def accumulate(trace_id)
+        accumulation = 0
+        (0...trace_id.length / 8).each do |i|
+          pos = i * 8
+          part = trace_id[pos, 8].to_i(16)
+          accumulation = (accumulation ^ part) & 0xffffffff
+        end
+        accumulation
+      end
+    end
+  end
+end
+

data/lib/multiplayer/version.rb

@@ -0,0 +1,3 @@
+module Multiplayer
+  VERSION = "0.0.1"
+end

data/lib/multiplayer_otlp.rb

@@ -0,0 +1,4 @@
+require_relative "multiplayer/multiplayer"
+module MultiplayerOTLP
+
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: multiplayer_otlp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Multiplayer Inc.
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-exporter-otlp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.29.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.29.1
+- !ruby/object:Gem::Dependency
+  name: json-schema-generator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/multiplayer/exporters/http_exporter.rb
+- lib/multiplayer/middleware/middleware.rb
+- lib/multiplayer/middleware/request_middleware.rb
+- lib/multiplayer/middleware/response_middleware.rb
+- lib/multiplayer/multiplayer.rb
+- lib/multiplayer/utils/id_generator.rb
+- lib/multiplayer/utils/json_schema_generator.rb
+- lib/multiplayer/utils/trace_id_ratio_based_sampler.rb
+- lib/multiplayer/version.rb
+- lib/multiplayer_otlp.rb
+homepage: https://rubygems.org/gems/multiplayer_otlp
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Multiplayer OTLP library
+test_files: []