elastic-transport 8.0.0 → 8.4.0

data/lib/elastic/transport/transport/base.rb

@@ -24,12 +24,12 @@ module Elastic
         include Loggable
 
         DEFAULT_PORT             = 9200
-        DEFAULT_PROTOCOL         = 'http'
+        DEFAULT_PROTOCOL         = 'http'.freeze
         DEFAULT_RELOAD_AFTER     = 10_000 # Requests
         DEFAULT_RESURRECT_AFTER  = 60     # Seconds
         DEFAULT_MAX_RETRIES      = 3      # Requests
         DEFAULT_SERIALIZER_CLASS = Serializer::MultiJson
-        SANITIZED_PASSWORD       = '*' * (rand(14)+1)
+        SANITIZED_PASSWORD       = '*' * (rand(14) + 1)
 
         attr_reader   :hosts, :options, :connections, :counter, :last_request_at, :protocol
         attr_accessor :serializer, :sniffer, :logger, :tracer,
@@ -59,7 +59,7 @@ module Elastic
           @compression = !!@options[:compression]
           @connections = __build_connections
 
-          @serializer  = options[:serializer] || ( options[:serializer_class] ? options[:serializer_class].new(self) : DEFAULT_SERIALIZER_CLASS.new(self) )
+          @serializer  = options[:serializer] || ( options[:serializer_class] ? options[:serializer_class].new(self) : DEFAULT_SERIALIZER_CLASS.new(self))
           @protocol    = options[:protocol] || DEFAULT_PROTOCOL
 
           @logger      = options[:logger]
@@ -72,7 +72,7 @@ module Elastic
           @reload_connections = options[:reload_connections]
           @reload_after    = options[:reload_connections].is_a?(Integer) ? options[:reload_connections] : DEFAULT_RELOAD_AFTER
           @resurrect_after = options[:resurrect_after] || DEFAULT_RESURRECT_AFTER
-          @retry_on_status = Array(options[:retry_on_status]).map { |d| d.to_i }
+          @retry_on_status = Array(options[:retry_on_status]).map(&:to_i)
         end
 
         # Returns a connection from the connection pool by delegating to {Connections::Collection#get_connection}.
@@ -83,11 +83,11 @@ module Elastic
         # @return [Connections::Connection]
         # @see    Connections::Collection#get_connection
         #
-        def get_connection(options={})
+        def get_connection(options = {})
           resurrect_dead_connections! if Time.now > @last_request_at + @resurrect_after
 
           @counter_mtx.synchronize { @counter += 1 }
-          reload_connections!         if reload_connections && counter % reload_after == 0
+          reload_connections! if reload_connections && (counter % reload_after).zero?
           connections.get_connection(options)
         end
 
@@ -97,10 +97,10 @@ module Elastic
         #
         def reload_connections!
           hosts = sniffer.hosts
-          __rebuild_connections :hosts => hosts, :options => options
+          __rebuild_connections(hosts: hosts, options: options)
           self
         rescue SnifferTimeoutError
-          log_error "[SnifferTimeoutError] Timeout when reloading connections."
+          log_error('[SnifferTimeoutError] Timeout when reloading connections.')
           self
         end
 
@@ -109,7 +109,7 @@ module Elastic
         # @see Connections::Connection#resurrect!
         #
         def resurrect_dead_connections!
-          connections.dead.each { |c| c.resurrect! }
+          connections.dead.each(&:resurrect!)
         end
 
         # Rebuilds the connections collection in the transport.
@@ -120,7 +120,7 @@ module Elastic
         # @return [Connections::Collection]
         # @api private
         #
-        def __rebuild_connections(arguments={})
+        def __rebuild_connections(arguments = {})
           @state_mutex.synchronize do
             @hosts       = arguments[:hosts]    || []
             @options     = arguments[:options]  || {}
@@ -128,7 +128,7 @@ module Elastic
             __close_connections
 
             new_connections = __build_connections
-            stale_connections = @connections.all.select  { |c| ! new_connections.include?(c) }
+            stale_connections = @connections.all.reject { |c| new_connections.include?(c) }
             new_connections = new_connections.reject { |c| @connections.all.include?(c) }
 
             @connections.remove(stale_connections)
@@ -177,8 +177,8 @@ module Elastic
         # @return [Connections::Connection]
         # @api    private
         #
-        def __build_connection(host, options={}, block=nil)
-          raise NoMethodError, "Implement this method in your class"
+        def __build_connection(host, options = {}, block = nil)
+          raise NoMethodError, 'Implement this method in your class'
         end
 
         # Closes the connections collection
@@ -209,14 +209,14 @@ module Elastic
         #
         def __trace(method, path, params, headers, body, url, response, json, took, duration)
           trace_url  = "http://localhost:9200/#{path}?pretty" +
-              ( params.empty? ? '' : "&#{::Faraday::Utils::ParamsHash[params].to_query}" )
+              (params.empty? ? '' : "&#{::Faraday::Utils::ParamsHash[params].to_query}")
           trace_body = body ? " -d '#{__convert_to_json(body, :pretty => true)}'" : ''
           trace_command = "curl -X #{method.to_s.upcase}"
-          trace_command += " -H '#{headers.collect { |k,v| "#{k}: #{v}" }.join(", ")}'" if headers && !headers.empty?
+          trace_command += " -H '#{headers.collect { |k, v| "#{k}: #{v}" }.join(", ")}'" if headers && !headers.empty?
           trace_command += " '#{trace_url}'#{trace_body}\n"
           tracer.info trace_command
           tracer.debug "# #{Time.now.iso8601} [#{response.status}] (#{format('%.3f', duration)}s)\n#"
-          tracer.debug json ? serializer.dump(json, :pretty => true).gsub(/^/, '# ').sub(/\}$/, "\n# }")+"\n" : "# #{response.body}\n"
+          tracer.debug json ? serializer.dump(json, pretty: true).gsub(/^/, '# ').sub(/\}$/, "\n# }")+"\n" : "# #{response.body}\n"
         end
 
         # Raise error specific for the HTTP response status or a generic server error
@@ -232,7 +232,7 @@ module Elastic
         #
         # @api private
         #
-        def __convert_to_json(o=nil, options={})
+        def __convert_to_json(o = nil, options = {})
           o.is_a?(String) ? o : serializer.dump(o, options)
         end
 
@@ -276,40 +276,37 @@ module Elastic
           reload_on_failure = opts.fetch(:reload_on_failure, @options[:reload_on_failure])
           delay_on_retry = opts.fetch(:delay_on_retry, @options[:delay_on_retry])
 
-          max_retries = if opts.key?(:retry_on_failure)
-            opts[:retry_on_failure] === true ? DEFAULT_MAX_RETRIES : opts[:retry_on_failure]
-          elsif options.key?(:retry_on_failure)
-            options[:retry_on_failure] === true ? DEFAULT_MAX_RETRIES : options[:retry_on_failure]
-          end
+          max_retries = max_retries(opts) || max_retries(options)
 
           params = params.clone
-          ignore = Array(params.delete(:ignore)).compact.map { |s| s.to_i }
+          # Transforms ignore status codes to Integer
+          ignore = Array(params.delete(:ignore)).compact.map(&:to_i)
 
           begin
             sleep(delay_on_retry / 1000.0) if tries > 0
-            tries     += 1
+            tries += 1
             connection = get_connection or raise Error.new('Cannot get new connection from pool.')
 
-            if connection.connection.respond_to?(:params) && connection.connection.params.respond_to?(:to_hash)
+            if connection.connection.respond_to?(:params) &&
+               connection.connection.params.respond_to?(:to_hash)
               params = connection.connection.params.merge(params.to_hash)
             end
 
-            url      = connection.full_url(path, params)
+            url = connection.full_url(path, params)
             response = block.call(connection, url)
-            connection.healthy! if connection.failures > 0
+            connection.healthy! if connection.failures.positive?
 
             # Raise an exception so we can catch it for `retry_on_status`
-            __raise_transport_error(response) if response.status.to_i >= 300 && @retry_on_status.include?(response.status.to_i)
+            __raise_transport_error(response) if response.status.to_i >= 300 &&
+                                                 @retry_on_status.include?(response.status.to_i)
           rescue Elastic::Transport::Transport::ServerError => e
-            if response && @retry_on_status.include?(response.status)
-              log_warn "[#{e.class}] Attempt #{tries} to get response from #{url}"
-              if tries <= (max_retries || DEFAULT_MAX_RETRIES)
-                retry
-              else
-                log_fatal "[#{e.class}] Cannot get response from #{url} after #{tries} tries"
-                raise e
-              end
+            raise e unless response && @retry_on_status.include?(response.status)
+
+            log_warn "[#{e.class}] Attempt #{tries} to get response from #{url}"
+            if tries <= (max_retries || DEFAULT_MAX_RETRIES)
+              retry
             else
+              log_fatal "[#{e.class}] Cannot get response from #{url} after #{tries} tries"
               raise e
             end
           rescue *host_unreachable_exceptions => e
@@ -317,21 +314,21 @@ module Elastic
 
             connection.dead!
 
-            if reload_on_failure and tries < connections.all.size
+            if reload_on_failure && tries < connections.all.size
               log_warn "[#{e.class}] Reloading connections (attempt #{tries} of #{connections.all.size})"
               reload_connections! and retry
             end
 
-            if max_retries
-              log_warn "[#{e.class}] Attempt #{tries} connecting to #{connection.host.inspect}"
-              if tries <= max_retries
-                retry
-              else
-                log_fatal "[#{e.class}] Cannot connect to #{connection.host.inspect} after #{tries} tries"
-                raise e
-              end
+            exception = Elastic::Transport::Transport::Error.new(e.message)
+
+            raise exception unless max_retries
+
+            log_warn "[#{e.class}] Attempt #{tries} connecting to #{connection.host.inspect}"
+            if tries <= max_retries
+              retry
             else
-              raise e
+              log_fatal "[#{e.class}] Cannot connect to #{connection.host.inspect} after #{tries} tries"
+              raise exception
             end
           rescue Exception => e
             log_fatal "[#{e.class}] #{e.message} (#{connection.host.inspect if connection})"
@@ -349,8 +346,18 @@ module Elastic
             __raise_transport_error response unless ignore.include?(response.status.to_i)
           end
 
-          json     = serializer.load(response.body) if response.body && !response.body.empty? && response.headers && response.headers["content-type"] =~ /json/
-          took     = (json['took'] ? sprintf('%.3fs', json['took']/1000.0) : 'n/a') rescue 'n/a'
+          if response.body &&
+            !response.body.empty? &&
+            response.headers &&
+            response.headers["content-type"] =~ /json/
+
+            # Prevent Float value from automatically becoming BigDecimal when using Oj
+            load_options = {}
+            load_options[:mode] = :compat if ::MultiJson.adapter.to_s == "MultiJson::Adapters::Oj"
+
+            json = serializer.load(response.body, load_options)
+          end
+          took = (json['took'] ? sprintf('%.3fs', json['took'] / 1000.0) : 'n/a') rescue 'n/a'
           __log_response(method, path, params, body, url, response, json, took, duration) unless ignore.include?(response.status.to_i)
           __trace(method, path, params, connection_headers(connection), body, url, response, nil, 'N/A', duration) if tracer
           log_warn(response.headers['warning']) if response.headers&.[]('warning')
@@ -372,17 +379,21 @@ module Elastic
         private
 
         USER_AGENT_STR = 'User-Agent'.freeze
-        USER_AGENT_REGEX = /user\-?\_?agent/
+        USER_AGENT_REGEX = /user-?_?agent/
         ACCEPT_ENCODING = 'Accept-Encoding'.freeze
         CONTENT_ENCODING = 'Content-Encoding'.freeze
         CONTENT_TYPE_STR = 'Content-Type'.freeze
-        CONTENT_TYPE_REGEX = /content\-?\_?type/
+        CONTENT_TYPE_REGEX = /content-?_?type/
         DEFAULT_CONTENT_TYPE = 'application/json'.freeze
         GZIP = 'gzip'.freeze
         GZIP_FIRST_TWO_BYTES = '1f8b'.freeze
         HEX_STRING_DIRECTIVE = 'H*'.freeze
         RUBY_ENCODING = '1.9'.respond_to?(:force_encoding)
 
+        def max_retries(opts)
+          opts[:retry_on_failure] == true ? DEFAULT_MAX_RETRIES : opts[:retry_on_failure]
+        end
+
         def compress_request(body, headers)
           if body
             headers ||= {}
@@ -409,7 +420,7 @@ module Elastic
 
           io = StringIO.new(body)
           gzip_reader = if RUBY_ENCODING
-                          Zlib::GzipReader.new(io, :encoding => 'ASCII-8BIT')
+                          Zlib::GzipReader.new(io, encoding: 'ASCII-8BIT')
                         else
                           Zlib::GzipReader.new(io)
                         end
@@ -427,7 +438,7 @@ module Elastic
         end
 
         def apply_headers(client, options)
-          headers = options[:headers] || {}
+          headers = options[:headers].clone || {}
           headers[CONTENT_TYPE_STR] = find_value(headers, CONTENT_TYPE_REGEX) || DEFAULT_CONTENT_TYPE
           headers[USER_AGENT_STR] = find_value(headers, USER_AGENT_REGEX) || user_agent_header(client)
           client.headers[ACCEPT_ENCODING] = GZIP if use_compression?
@@ -442,7 +453,7 @@ module Elastic
           end
         end
 
-        def user_agent_header(client)
+        def user_agent_header(_client)
           @user_agent ||= begin
             meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
             if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
@@ -453,12 +464,21 @@ module Elastic
         end
 
         def connection_headers(connection)
-          if defined?(Elastic::Transport::Transport::HTTP::Manticore) && self.class == Elastic::Transport::Transport::HTTP::Manticore
+          if defined?(Elastic::Transport::Transport::HTTP::Manticore) &&
+             instance_of?(Elastic::Transport::Transport::HTTP::Manticore)
             @request_options[:headers]
           else
             connection.connection.headers
           end
         end
+
+        def capture_otel_span_attributes(connection, url)
+          if defined?(::OpenTelemetry)
+            ::OpenTelemetry::Trace.current_span&.set_attribute('url.full', url)
+            ::OpenTelemetry::Trace.current_span&.set_attribute('server.address', connection.host[:host])
+            ::OpenTelemetry::Trace.current_span&.set_attribute('server.port', connection.host[:port].to_i)
+          end
+        end
       end
     end
   end

data/lib/elastic/transport/transport/errors.rb

@@ -18,7 +18,6 @@
 module Elastic
   module Transport
     module Transport
-
       # Generic client error
       #
       class Error < StandardError; end
@@ -78,14 +77,13 @@ module Elastic
         505 => 'HTTPVersionNotSupported',
         506 => 'VariantAlsoNegotiates',
         510 => 'NotExtended'
-      }
+      }.freeze
 
-      ERRORS = HTTP_STATUSES.inject({}) do |sum, error|
+      ERRORS = HTTP_STATUSES.each_with_object({}) do |error, sum|
         status, name = error
         sum[status] = Errors.const_set name, Class.new(ServerError)
         sum
       end
-
     end
   end
 end

data/lib/elastic/transport/transport/http/curb.rb

@@ -31,37 +31,41 @@ module Elastic
           # @see    Transport::Base#perform_request
           #
           def perform_request(method, path, params={}, body=nil, headers=nil, opts={})
-            super do |connection, _url|
+            super do |connection, url|
+              capture_otel_span_attributes(connection, url)
               connection.connection.url = connection.full_url(path, params)
               body = body ? __convert_to_json(body) : nil
               body, headers = compress_request(body, headers)
 
               case method
-                when 'HEAD'
-                  connection.connection.set :nobody, true
-                when 'GET', 'POST', 'PUT', 'DELETE'
-                  connection.connection.set :nobody, false
-                  connection.connection.put_data = body if body
+              when 'HEAD'
+                connection.connection.set :nobody, true
+              when 'GET', 'POST', 'PUT', 'DELETE'
+                connection.connection.set :nobody, false
+                connection.connection.put_data = body if body
 
-                  if headers
-                    if connection.connection.headers
-                      connection.connection.headers.merge!(headers)
-                    else
-                      connection.connection.headers = headers
-                    end
+                if headers
+                  if connection.connection.headers
+                    connection.connection.headers.merge!(headers)
+                  else
+                    connection.connection.headers = headers
                   end
+                end
 
-                else raise ArgumentError, "Unsupported HTTP method: #{method}"
+              else raise ArgumentError, "Unsupported HTTP method: #{method}"
               end
 
               connection.connection.http(method.to_sym)
+              header_string = connection.connection.header_str.to_s
 
-              response_headers = {}
-              response_headers['content-type'] = 'application/json' if connection.connection.header_str =~ /\/json/
+              _response_status, *response_headers = header_string.split(/[\r\n]+/).map(&:strip)
+              response_headers = Hash[response_headers.flat_map { |s| s.scan(/^(\S+): (.+)/) }].transform_keys(&:downcase)
 
-              Response.new connection.connection.response_code,
-                           decompress_response(connection.connection.body_str),
-                           response_headers
+              Response.new(
+                connection.connection.response_code,
+                decompress_response(connection.connection.body_str),
+                response_headers
+              )
             end
           end
 
@@ -73,7 +77,7 @@ module Elastic
             client = ::Curl::Easy.new
 
             apply_headers(client, options)
-            client.url     = __full_url(host)
+            client.url = __full_url(host)
 
             if host[:user]
               client.http_auth_types = host[:auth_type] || :basic
@@ -105,13 +109,13 @@ module Elastic
 
           def user_agent_header(client)
             @user_agent ||= begin
-              meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
-              if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
-                meta << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} #{RbConfig::CONFIG['target_cpu']}"
-              end
-              meta << "Curb #{Curl::CURB_VERSION}"
-              "elastic-transport-ruby/#{VERSION} (#{meta.join('; ')})"
-            end
+                              meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
+                              if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
+                                meta << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} #{RbConfig::CONFIG['target_cpu']}"
+                              end
+                              meta << "Curb #{Curl::CURB_VERSION}"
+                              "elastic-transport-ruby/#{VERSION} (#{meta.join('; ')})"
+                            end
           end
         end
       end

data/lib/elastic/transport/transport/http/faraday.rb

@@ -34,26 +34,28 @@ module Elastic
           #
           def perform_request(method, path, params = {}, body = nil, headers = nil, opts = {})
             super do |connection, url|
-              headers = if connection.connection.headers
-                          if !headers.nil?
-                            connection.connection.headers.merge(headers)
-                          else
-                            connection.connection.headers
-                          end
-                        else
-                          headers
-                        end
+              capture_otel_span_attributes(connection, url)
+              headers = parse_headers(headers, connection)
               body = body ? __convert_to_json(body) : nil
               body, headers = compress_request(body, headers)
 
-              response = connection.connection.run_request(
-                method.downcase.to_sym,
-                url,
-                body,
-                headers
-              )
+              response = connection.connection.run_request(method.downcase.to_sym, url, body, headers)
 
-              Response.new response.status, decompress_response(response.body), response.headers
+              Response.new(response.status, decompress_response(response.body), response.headers)
+            end
+          end
+
+          # Merges headers already present in the connection and the ones passed in to perform_request
+          #
+          def parse_headers(headers, connection)
+            if connection.connection.headers
+              if !headers.nil?
+                connection.connection.headers.merge(headers)
+              else
+                connection.connection.headers
+              end
+            else
+              headers
             end
           end
 
@@ -73,10 +75,10 @@ module Elastic
           #
           def host_unreachable_exceptions
             [
-                ::Faraday::ConnectionFailed,
-                ::Faraday::TimeoutError,
-                ::Faraday.const_defined?(:ServerError) ? ::Faraday::ServerError : nil,
-                ::Faraday::SSLError
+              ::Faraday::ConnectionFailed,
+              ::Faraday::TimeoutError,
+              ::Faraday.const_defined?(:ServerError) ? ::Faraday::ServerError : nil,
+              ::Faraday::SSLError
             ].compact
           end
 
@@ -84,13 +86,14 @@ module Elastic
 
           def user_agent_header(client)
             @user_agent ||= begin
-              meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
-              if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
-                meta << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} #{RbConfig::CONFIG['target_cpu']}"
-              end
-              meta << "#{client.headers[USER_AGENT_STR]}"
-              "elastic-transport-ruby/#{VERSION} (#{meta.join('; ')})"
-            end
+                              meta = ["RUBY_VERSION: #{RUBY_VERSION}"]
+                              if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
+                                meta << "#{RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase} " \
+                                        "#{RbConfig::CONFIG['target_cpu']}"
+                              end
+                              meta << client.headers[USER_AGENT_STR]
+                              "elastic-transport-ruby/#{VERSION} (#{meta.join('; ')})"
+                            end
           end
         end
       end

data/lib/elastic/transport/transport/http/manticore.rb

@@ -89,12 +89,12 @@ module Elastic
           #
           def perform_request(method, path, params = {}, body = nil, headers = nil, opts = {})
             super do |connection, url|
+              capture_otel_span_attributes(connection, url)
               body = body ? __convert_to_json(body) : nil
-              body, headers = compress_request(body, @request_options[:headers])
-
+              body, headers = compress_request(body, parse_headers(headers))
               params[:body] = body if body
               params[:headers] = headers if headers
-              params = params.merge @request_options
+
               case method
               when 'GET'
                 resp = connection.connection.get(url, params)
@@ -161,8 +161,14 @@ module Elastic
 
           private
 
+          def parse_headers(headers)
+            request_headers = @request_options.fetch(:headers, {})
+            headers = request_headers.merge(headers || {})
+            headers.empty? ? nil : headers
+          end
+
           def apply_headers(options)
-            headers = options[:headers] || options.dig(:transport_options, :headers) || {}
+            headers = options[:headers].clone || options.dig(:transport_options, :headers).clone || {}
             headers[CONTENT_TYPE_STR] = find_value(headers, CONTENT_TYPE_REGEX) || DEFAULT_CONTENT_TYPE
             headers[USER_AGENT_STR] = find_value(headers, USER_AGENT_REGEX) || find_value(@request_options[:headers], USER_AGENT_REGEX) || user_agent_header
             headers[ACCEPT_ENCODING] = GZIP if use_compression?

data/lib/elastic/transport/transport/response.rb

@@ -19,16 +19,16 @@ module Elastic
   module Transport
     module Transport
       # Wraps the response from Elasticsearch.
-      #
+      # It provides `body`, `status` and `headers` methods
       class Response
         attr_reader :status, :body, :headers
 
         # @param status  [Integer] Response status code
         # @param body    [String]  Response body
         # @param headers [Hash]    Response headers
-        def initialize(status, body, headers={})
+        def initialize(status, body, headers = {})
           @status, @body, @headers = status, body, headers
-          @body = body.force_encoding('UTF-8') if body.respond_to?(:force_encoding)
+          @body = body.force_encoding('UTF-8') if body.respond_to?(:force_encoding) && !body.frozen?
         end
       end
     end

data/lib/elastic/transport/transport/serializer/multi_json.rb

@@ -24,7 +24,7 @@ module Elastic
         module Base
           # @param transport [Object] The instance of transport which uses this serializer
           #
-          def initialize(transport=nil)
+          def initialize(transport = nil)
             @transport = transport
           end
         end
@@ -36,13 +36,13 @@ module Elastic
 
           # De-serialize a Hash from JSON string
           #
-          def load(string, options={})
+          def load(string, options = {})
             ::MultiJson.load(string, options)
           end
 
           # Serialize a Hash to JSON string
           #
-          def dump(object, options={})
+          def dump(object, options = {})
             ::MultiJson.dump(object, options)
           end
         end

data/lib/elastic/transport/transport/sniffer.rb

@@ -76,7 +76,9 @@ module Elastic
         end
 
         def parse_publish_address(publish_address)
-          # publish_address is in the format hostname/ip:port
+          # When publish_address is in the format 'inet[hostname/ip:port]'
+          return parse_address_port(publish_address[6..-2]) if publish_address =~ /^inet\[.*\]$/
+
           if publish_address =~ /\//
             parts = publish_address.partition('/')
             [ parts[0], parse_address_port(parts[2])[1] ]

data/lib/elastic/transport/version.rb

@@ -17,6 +17,6 @@
 
 module Elastic
   module Transport
-    VERSION = '8.0.0'.freeze
+    VERSION = '8.4.0'.freeze
   end
 end

data/lib/elastic/transport.rb

@@ -34,5 +34,6 @@ require 'elastic/transport/transport/connections/collection'
 require 'elastic/transport/transport/http/faraday'
 require 'elastic/transport/client'
 require 'elastic/transport/redacted'
+require 'elastic/transport/opentelemetry'
 
 require 'elastic/transport/version'