getstream-ruby 6.1.1 → 7.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f8a1dd8b4379c6af81682b352877f55c651f081265e87cc5ec08a477b19c91d
-  data.tar.gz: 7b46eb14dac0d23a0f76223244125ec4ff54ee2130f5b554fae68e363ac7ac00
+  metadata.gz: 388126d2a284a9b97ac8eb6cd1793088ccfc51992504de016192d7974d582e3e
+  data.tar.gz: 3fb211b156d236f9b27734651215351d9a3a370d6d6a1da52bfe5fa779cdf7b9
 SHA512:
-  metadata.gz: 4b88721605b6c6cc61769dee8c0940ad9b351676a7ed77c0ac9799f898dc3c297534dff333710617ebd4de527387b3273b66a31c7b49808d18f08f908b91d172
-  data.tar.gz: 58ccb9e4f16e22cce7dfff31c915f9c2c4c9be2a3f5a3e14ad6c31182f1ebb4da3cdecf63321ca19920abe15be0ce1a669e248ceaa80aab99c4a3413150669ea
+  metadata.gz: ebae01df899c155f88efa4296b92766df5cc08f9dbd6b81188de15ddccc791eb7a5d4c1f8767c8e20c95601c109fb07de9e586bcb028786f8f6ce4904ad76352
+  data.tar.gz: 487609c26921506f9b5ea2cccedec98911adcd831189b785ede0963d75df993fa4ff768745574c37ac4d2f10764677f104c8ff403b1bef87f2ea867874abdd63

data/README.md

@@ -350,18 +350,20 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/getstr
 
 ## Release Process
 
-Releases use two paths:
+Releases use two paths, both handled by `.github/workflows/release.yml`:
 
-- Default: automatic release when a PR is merged to `main`/`master`.
-- Fallback: manual release using `.github/workflows/manual-release.yml` (admin use only).
+- **Default**: automatic release when a PR is merged to `main`/`master`. The PR title (and body) drives the semver bump.
+- **Fallback**: manual release via the `Release` workflow's `workflow_dispatch` (admin use). Select a `version_bump` (`patch`/`minor`/`major`). `use_current_version=true` skips the bump and publishes whatever is already in `lib/getstream_ruby/version.rb`.
 
-Automatic semver bump rules are based on merged PR title/body:
+Automatic semver bump rules:
 
 - `feat:` -> minor
 - `fix:` (or `bug:`) -> patch
-- `feat!:` or `BREAKING CHANGE` in PR body -> major
+- `feat!:`, `<type>(scope)!:`, or `BREAKING CHANGE` in the PR body/title -> major
 
-PRs with other prefixes do not trigger a release.
+PRs with any other prefix do not trigger a release.
+
+The release pipeline runs lint (`make format-check && make lint && make security`), the unit suite (`make test`), and all three integration suites (chat, feed, video) on the merged commit before publishing to RubyGems. Each step is idempotent; a failed run can be re-dispatched from the Actions UI.
 
 ## License
 

data/lib/getstream_ruby/client.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
 require 'faraday'
+require 'faraday/gzip'
 require 'faraday/retry'
 require 'faraday/multipart'
+require 'faraday/net_http_persistent'
+require 'logger'
 require 'json'
 require 'jwt'
 require_relative 'generated/base_model'
@@ -13,7 +16,10 @@ require_relative 'generated/chat_client'
 require_relative 'generated/video_client'
 require_relative 'extensions/moderation_extensions'
 require_relative 'generated/feed'
+require_relative 'generated/webhook'
+require_relative 'generated/models/api_error'
 require_relative 'stream_response'
+require_relative 'error_mapping'
 
 module GetStreamRuby
 
@@ -35,6 +41,7 @@ module GetStreamRuby
 
       @configuration.validate!
       @connection = build_connection
+      @configuration.log_pool_config_to(@configuration.logger)
     end
 
     def feed_resource
@@ -76,6 +83,52 @@ module GetStreamRuby
       GetStream::Generated::Feed.new(self, feed_group_id, feed_id)
     end
 
+    # Verify a webhook signature using this client's API secret (CHA-2961).
+    #
+    # Convenience wrapper around StreamChat::Webhook.verify_signature that
+    # supplies the secret automatically. The module-level method is still
+    # available for callers that need to verify with an arbitrary secret.
+    #
+    # @param body [String] The raw request body (already-decompressed)
+    # @param signature [String] The signature from the X-Signature header
+    # @return [Boolean] true if the signature is valid, false otherwise
+    def verify_signature(body, signature)
+      StreamChat::Webhook.verify_signature(body, signature, @configuration.api_secret)
+    end
+
+    # Verify and parse a webhook payload in one call, using this client's API
+    # secret (CHA-2961).
+    #
+    # Handles gzip-compressed bodies transparently. Raises
+    # StreamChat::Webhook::InvalidWebhookError on signature mismatch or parse
+    # failures; distinguish failure modes via the message substring.
+    #
+    # @param body [String] raw request body (possibly gzip-compressed)
+    # @param signature [String] X-Signature header value
+    # @return [Object] the typed event class instance or
+    #         StreamChat::Webhook::UnknownEvent
+    # @raise [StreamChat::Webhook::InvalidWebhookError]
+    def verify_and_parse_webhook(body, signature)
+      StreamChat::Webhook.verify_and_parse_webhook(body, signature, @configuration.api_secret)
+    end
+
+    # Decode + parse a Stream-delivered SQS message body.
+    #
+    # Convenience wrapper around StreamChat::Webhook.parse_sqs. No signature is
+    # required; SQS deliveries are authenticated via AWS IAM.
+    def parse_sqs(message_body)
+      StreamChat::Webhook.parse_sqs(message_body)
+    end
+
+    # Decode + parse a Stream-delivered SNS notification body.
+    #
+    # Accepts either the raw SNS HTTP envelope JSON or the pre-extracted Message
+    # string. Convenience wrapper around StreamChat::Webhook.parse_sns. No signature
+    # is required; SNS deliveries are authenticated via AWS IAM.
+    def parse_sns(notification_body)
+      StreamChat::Webhook.parse_sns(notification_body)
+    end
+
     # @param path [String] The API path
     # @param body [Hash] The request body
     # @return [GetStreamRuby::StreamResponse] The API response
@@ -83,7 +136,50 @@ module GetStreamRuby
       request(:post, path, body)
     end
 
-    def make_request(method, path, query_params: nil, body: nil)
+    # Polls the task-status endpoint until the task reaches a terminal state.
+    #
+    # Behaviour:
+    #   - status="completed": returns the task `result` payload.
+    #   - status="failed":    raises `TaskError` populated from the task's
+    #                         `ErrorResult` (`type`, `description`, `stacktrace`,
+    #                         `version`).
+    #   - timeout elapsed:    raises `TransportError` with `error_type:
+    #                         "timeout"`.
+    #
+    # @param task_id [String]
+    # @param poll_interval [Numeric] seconds between polls (default 1)
+    # @param timeout [Numeric] max seconds to wait (default 60)
+    # @return [Object] the task `result` payload on success
+    # @raise [TaskError] when the task reports `status="failed"`
+    # @raise [TransportError] when the timeout elapses (`error_type="timeout"`)
+    def wait_for_task(task_id, poll_interval: 1, timeout: 60)
+      start_time = monotonic_now
+
+      loop do
+
+        response = common.get_task(task_id)
+        status = response.status
+
+        case status
+        when 'completed'
+          return response.result
+        when 'failed'
+          raise ErrorMapping.build_task_error(task_id, response.error)
+        end
+
+        if monotonic_now - start_time >= timeout
+          raise TransportError.new(
+            "wait_for_task timed out after #{timeout}s for task_id=#{task_id}",
+            error_type: 'timeout',
+          )
+        end
+
+        sleep(poll_interval)
+
+      end
+    end
+
+    def make_request(method, path, query_params: nil, body: nil, request_timeout: nil)
       # Handle query parameters
       if query_params && !query_params.empty?
         query_string = query_params.map { |k, v| "#{k}=#{v}" }.join('&')
@@ -91,12 +187,12 @@ module GetStreamRuby
       end
 
       # Make the request
-      request(method, path, body)
+      request(method, path, body, request_timeout: request_timeout)
     end
 
     private
 
-    def request(method, path, data = {})
+    def request(method, path, data = {}, request_timeout: nil)
       # Add API key to query parameters
       query_params = { api_key: @configuration.api_key }
 
@@ -111,15 +207,20 @@ module GetStreamRuby
         req.headers['stream-auth-type'] = 'jwt'
         req.headers['X-Stream-Client'] = user_agent
         req.body = data.to_json
+        req.options.timeout = request_timeout if request_timeout
 
       end
 
       handle_response(response)
     rescue Faraday::Error => e
-      raise APIError, "Request failed: #{e.message}"
+      raise TransportError.new("Request failed: #{e.message}", error_type: ErrorMapping.classify_faraday_error(e))
     end
 
     def build_connection
+      # Escape hatch #1: user supplied a fully-built Faraday::Connection.
+      # Use it as-is; none of the 5 knobs apply.
+      return @configuration.http_client if @configuration.http_client
+
       Faraday.new(url: @configuration.base_url) do |conn|
 
         conn.request :multipart
@@ -130,22 +231,44 @@ module GetStreamRuby
           backoff_factor: 2,
         }
         conn.response :json, content_type: /\bjson$/
-        conn.headers['Connection'] = 'keep-alive' if @configuration.connection_keep_alive
+        # :gzip must come after :json (Faraday runs response middleware in reverse).
+        conn.request :gzip
         configure_adapter(conn)
-        conn.options.timeout = @configuration.timeout
+
+        conn.options.timeout = @configuration.request_timeout
+        conn.options.open_timeout = @configuration.connect_timeout
 
       end
     end
 
     def configure_adapter(connection)
-      adapter = @configuration.faraday_adapter || Faraday.default_adapter
-      adapter_options = @configuration.faraday_adapter_options || {}
-      connection.adapter(adapter, **adapter_options)
+      # Escape hatch #2: custom adapter symbol. Use it with the user's
+      # adapter_options; do NOT apply pool_size/idle_timeout (those are
+      # net_http_persistent-specific).
+      if @configuration.faraday_adapter
+        adapter = @configuration.faraday_adapter
+        adapter_options = @configuration.faraday_adapter_options || {}
+        # Header-based keep-alive only on the custom-adapter path.
+        # net_http_persistent (default) keeps connections alive natively without any HTTP header.
+        connection.headers['Connection'] = 'keep-alive' if @configuration.connection_keep_alive
+        connection.adapter(adapter, **adapter_options)
+        return
+      end
+
+      # Default: net_http_persistent with the 5-knob config.
+      # Never set Connection: close; net_http_persistent keeps connections alive natively.
+      idle = @configuration.idle_timeout
+      connection.adapter :net_http_persistent, pool_size: @configuration.max_conns_per_host do |http|
+
+        http.idle_timeout = idle
+
+      end
     rescue Faraday::Error, ArgumentError => e
-      @configuration.logger&.warn(
-        "Falling back to #{Faraday.default_adapter}: could not use adapter #{adapter} (#{e.message})",
-      )
+      # A fallback silently disables pooling, so always WARN (never swallow).
+      @configuration.warn_pool_fallback(Faraday.default_adapter, e)
       connection.adapter Faraday.default_adapter
+      # Record the adapter actually built so the INFO log reports it accurately.
+      @configuration.effective_adapter = Faraday.default_adapter.to_s
     end
 
     def generate_auth_header
@@ -164,29 +287,13 @@ module GetStreamRuby
     end
 
     def handle_response(response)
-      case response.status
-      when 200..299
-        StreamResponse.new(response.body)
-      else
-        # Parse JSON response body if it's a string
-        parsed_body = if response.body.is_a?(String)
-                        begin
-                          JSON.parse(response.body)
-                        rescue JSON::ParserError
-                          response.body
-                        end
-                      else
-                        response.body
-                      end
-
-        error_message = if parsed_body.is_a?(Hash)
-                          parsed_body['message'] || parsed_body['detail'] ||
-                            "Request failed with status #{response.status}"
-                        else
-                          "Request failed with status #{response.status}"
-                        end
-        raise APIError, error_message
-      end
+      return StreamResponse.new(response.body) if (200..299).cover?(response.status)
+
+      ErrorMapping.raise_api_error(response)
+    end
+
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
     def multipart_request?(data)
@@ -202,10 +309,10 @@ module GetStreamRuby
       payload = {}
 
       # Handle file field
-      raise APIError, 'file name must be provided' if data.file.nil? || data.file.empty?
+      raise ArgumentError, 'file name must be provided' if data.file.nil? || data.file.empty?
 
       file_path = data.file
-      raise APIError, "file not found: #{file_path}" unless File.exist?(file_path)
+      raise ArgumentError, "file not found: #{file_path}" unless File.exist?(file_path)
 
       # Determine content type
       content_type = detect_content_type(file_path)
@@ -241,7 +348,7 @@ module GetStreamRuby
 
       handle_response(response)
     rescue Faraday::Error => e
-      raise APIError, "Request failed: #{e.message}"
+      raise TransportError.new("Request failed: #{e.message}", error_type: ErrorMapping.classify_faraday_error(e))
     end
 
     def detect_content_type(file_path)

data/lib/getstream_ruby/configuration.rb

@@ -1,45 +1,27 @@
 # frozen_string_literal: true
 
+require 'logger'
+
 module GetStreamRuby
 
   class Configuration
 
     attr_accessor :api_key, :api_secret, :base_url, :timeout, :logger, :faraday_adapter, :faraday_adapter_options,
-                  :connection_keep_alive
+                  :connection_keep_alive, :max_conns_per_host, :idle_timeout, :connect_timeout,
+                  :request_timeout, :http_client, :effective_adapter
 
     def initialize(api_key: nil, api_secret: nil, use_env: true, **options)
-      base_url = options[:base_url]
-      timeout = options[:timeout]
       http_options = options[:http_options] || {}
-      faraday_adapter = options[:faraday_adapter] || http_options[:faraday_adapter]
-      faraday_adapter_options = options[:faraday_adapter_options] || http_options[:faraday_adapter_options]
-      connection_keep_alive = if options.key?(:connection_keep_alive)
-                                options[:connection_keep_alive]
-                              else
-                                http_options[:connection_keep_alive]
-                              end
 
-      if use_env
-        @api_key = api_key || ENV.fetch('STREAM_API_KEY', nil)
-        @api_secret = api_secret || ENV.fetch('STREAM_API_SECRET', nil)
-        @base_url = base_url || ENV['STREAM_BASE_URL'] || 'https://chat.stream-io-api.com'
-        @timeout = timeout || (ENV['STREAM_TIMEOUT'] || 30).to_i
-      else
-        # Manual configuration only - no environment variables
-        @api_key = api_key
-        @api_secret = api_secret
-        @base_url = base_url || 'https://chat.stream-io-api.com'
-        @timeout = timeout || 30
-      end
+      assign_credentials_and_url(api_key, api_secret, options[:base_url], use_env: use_env)
+      assign_timeouts_and_pool(options, use_env: use_env)
+      assign_adapter(options, http_options)
+      assign_keep_alive(options, http_options)
 
-      @faraday_adapter = (faraday_adapter || ENV.fetch('STREAM_FARADAY_ADAPTER', nil))&.to_sym
-      @faraday_adapter_options = faraday_adapter_options || default_adapter_options
-      @connection_keep_alive = if connection_keep_alive.nil?
-                                 ENV.fetch('STREAM_CONNECTION_KEEP_ALIVE', 'true') == 'true'
-                               else
-                                 connection_keep_alive
-                               end
-      @logger = nil
+      # Keep @timeout in sync with @request_timeout for backwards compatibility.
+      @timeout = @request_timeout
+      @http_client = options[:http_client]
+      @logger = options[:logger]
     end
 
     def valid?
@@ -57,9 +39,54 @@ module GetStreamRuby
         api_secret: @api_secret,
         base_url: @base_url,
         timeout: @timeout,
+        request_timeout: @request_timeout,
+        max_conns_per_host: @max_conns_per_host,
+        idle_timeout: @idle_timeout,
+        connect_timeout: @connect_timeout,
+        http_client: @http_client,
         faraday_adapter: @faraday_adapter,
         faraday_adapter_options: @faraday_adapter_options.dup,
         connection_keep_alive: @connection_keep_alive,
+        logger: @logger,
+      )
+    end
+
+    # Emit a single INFO line listing the 5 effective pool knobs plus the active escape hatch (CHA-2956).
+    # If no logger is supplied, a default $stdout INFO logger is used.
+    # The faraday_adapter label reflects the adapter actually built
+    # (effective_adapter, set by Client#configure_adapter) so a silent fallback
+    # to the default adapter is never misreported as the requested adapter.
+    def log_pool_config_to(logger)
+      logger ||= Logger.new($stdout).tap { |l| l.level = Logger::INFO }
+      flag = @http_client ? 'user_http_client=true' : 'user_http_client=false'
+      adapter_label = if @http_client
+                        'user-supplied'
+                      elsif @effective_adapter
+                        @effective_adapter
+                      elsif @faraday_adapter
+                        @faraday_adapter.to_s
+                      else
+                        'default'
+                      end
+      fmt = 'connection pool: max_conns_per_host=%<m>d idle_timeout=%<i>d ' \
+            'connect_timeout=%<c>d request_timeout=%<r>d %<flag>s faraday_adapter=%<a>s'
+      logger.info(
+        format(
+          fmt,
+          m: @max_conns_per_host, i: @idle_timeout, c: @connect_timeout,
+          r: @request_timeout, flag: flag, a: adapter_label
+        ),
+      )
+    end
+
+    # Emit a WARNING that the requested adapter could not be built and pooling
+    # is disabled (CHA-2956). A fallback must never be silent, so when no logger
+    # is configured this uses a default $stdout logger, exactly like
+    # log_pool_config_to.
+    def warn_pool_fallback(fallback_adapter, error)
+      warn_logger = @logger || Logger.new($stdout).tap { |l| l.level = Logger::WARN }
+      warn_logger.warn(
+        "Falling back to #{fallback_adapter}: could not configure net_http_persistent (#{error.message})",
       )
     end
 
@@ -90,6 +117,59 @@ module GetStreamRuby
       {}
     end
 
+    def assign_credentials_and_url(api_key, api_secret, base_url, use_env:)
+      if use_env
+        @api_key = api_key || ENV.fetch('STREAM_API_KEY', nil)
+        @api_secret = api_secret || ENV.fetch('STREAM_API_SECRET', nil)
+        @base_url = base_url || ENV.fetch('STREAM_BASE_URL', nil) || 'https://chat.stream-io-api.com'
+      else
+        @api_key = api_key
+        @api_secret = api_secret
+        @base_url = base_url || 'https://chat.stream-io-api.com'
+      end
+    end
+
+    def assign_timeouts_and_pool(options, use_env:)
+      timeout = options[:timeout]
+      request_timeout = options[:request_timeout]
+      max_conns_per_host = options[:max_conns_per_host]
+      idle_timeout = options[:idle_timeout]
+      connect_timeout = options[:connect_timeout]
+
+      if use_env
+        env_request_timeout = ENV.fetch('STREAM_REQUEST_TIMEOUT', nil) || ENV.fetch('STREAM_TIMEOUT', nil)
+        @request_timeout = (request_timeout || timeout || env_request_timeout || 30).to_i
+        @max_conns_per_host = (max_conns_per_host || ENV.fetch('STREAM_MAX_CONNS_PER_HOST', nil) || 5).to_i
+        @idle_timeout = (idle_timeout || ENV.fetch('STREAM_IDLE_TIMEOUT', nil) || 55).to_i
+        @connect_timeout = (connect_timeout || ENV.fetch('STREAM_CONNECT_TIMEOUT', nil) || 10).to_i
+      else
+        @request_timeout = (request_timeout || timeout || 30).to_i
+        @max_conns_per_host = (max_conns_per_host || 5).to_i
+        @idle_timeout = (idle_timeout || 55).to_i
+        @connect_timeout = (connect_timeout || 10).to_i
+      end
+    end
+
+    def assign_adapter(options, http_options)
+      faraday_adapter = options[:faraday_adapter] || http_options[:faraday_adapter]
+      faraday_adapter_options = options[:faraday_adapter_options] || http_options[:faraday_adapter_options]
+      @faraday_adapter = (faraday_adapter || ENV.fetch('STREAM_FARADAY_ADAPTER', nil))&.to_sym
+      @faraday_adapter_options = faraday_adapter_options || default_adapter_options
+    end
+
+    def assign_keep_alive(options, http_options)
+      connection_keep_alive = if options.key?(:connection_keep_alive)
+                                options[:connection_keep_alive]
+                              else
+                                http_options[:connection_keep_alive]
+                              end
+      @connection_keep_alive = if connection_keep_alive.nil?
+                                 ENV.fetch('STREAM_CONNECTION_KEEP_ALIVE', 'true') == 'true'
+                               else
+                                 connection_keep_alive
+                               end
+    end
+
   end
 
 end

data/lib/getstream_ruby/error_mapping.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+
+module GetStreamRuby
+
+  # Translates HTTP responses and Faraday errors into SDK exceptions.
+  module ErrorMapping
+
+    module_function
+
+    # Raises the appropriate `ApiError` / `RateLimitError` for a non-2xx
+    # `Faraday::Response`.
+    def raise_api_error(response)
+      parsed_body = parse_error_body(response.body)
+      raw_body = stringify_body(response.body)
+
+      if parsed_body.is_a?(Hash)
+        api_error = GetStream::Generated::Models::APIError.new(parsed_body)
+        attrs = api_error_attrs(api_error, response.status, raw_body)
+
+        if response.status == 429
+          raise RateLimitError.new(
+            retry_after: parse_retry_after(response_header(response, 'Retry-After')),
+            **attrs,
+          )
+        end
+
+        raise ApiError.new(**attrs)
+      end
+
+      raise ApiError.new(
+        message: 'failed to parse error response',
+        status_code: response.status,
+        code: 0,
+        exception_fields: {},
+        unrecoverable: false,
+        raw_response_body: raw_body,
+        more_info: nil,
+        details: nil,
+      )
+    end
+
+    def api_error_attrs(model, status, raw_body)
+      {
+        message: model.message || "Request failed with status #{status}",
+        status_code: status,
+        code: model.code || 0,
+        exception_fields: model.exception_fields || {},
+        unrecoverable: model.unrecoverable.nil? ? false : model.unrecoverable,
+        raw_response_body: raw_body,
+        more_info: model.more_info,
+        details: model.details,
+      }
+    end
+
+    def parse_error_body(body)
+      return body if body.is_a?(Hash)
+      return nil unless body.is_a?(String) && !body.empty?
+
+      JSON.parse(body)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def stringify_body(body)
+      return '' if body.nil?
+      return body if body.is_a?(String)
+
+      body.to_json
+    end
+
+    def response_header(response, name)
+      headers = response.headers
+      return nil if headers.nil?
+
+      # Faraday normalizes header names to lowercase, but tolerate either form.
+      headers[name] || headers[name.downcase] || headers[name.to_s]
+    end
+
+    # Parse Retry-After header. Returns Float seconds. Returns nil when absent or
+    # unparseable. Past HTTP-dates clamp to 0.
+    def parse_retry_after(header)
+      return nil if header.nil?
+
+      value = header.to_s.strip
+      return nil if value.empty?
+      return value.to_f if value.match?(/\A\d+\z/)
+
+      begin
+        target = Time.httpdate(value)
+        delta = target - Time.now
+        delta.negative? ? 0.0 : delta.to_f
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    def classify_faraday_error(error)
+      case error
+      when Faraday::TimeoutError
+        'timeout'
+      when Faraday::SSLError
+        'tls_handshake_failed'
+      when Faraday::ConnectionFailed
+        classify_connection_failure(error)
+      else
+        'unknown'
+      end
+    end
+
+    def classify_connection_failure(error)
+      wrapped = error.respond_to?(:wrapped_exception) ? error.wrapped_exception : nil
+      case wrapped
+      when SocketError
+        'dns_failure'
+      else
+        'connection_reset'
+      end
+    end
+
+    def build_task_error(task_id, error_payload)
+      hash = if error_payload.respond_to?(:to_h)
+               error_payload.to_h
+             else
+               error_payload || {}
+             end
+      TaskError.new(
+        task_id: task_id,
+        error_type: lookup(hash, :type) || '',
+        description: lookup(hash, :description) || '',
+        stack_trace: lookup(hash, :stacktrace),
+        version: lookup(hash, :version),
+      )
+    end
+
+    def lookup(hash, key)
+      hash[key] || hash[key.to_s]
+    end
+
+  end
+
+end