elastic-transport 8.2.5 → 8.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f216469707e9c57ce1ef8c9285504300763bc3603b95bb25d434c4d4cb584fec
-  data.tar.gz: 6ae9924b648db98d0a5d7d2f6770f0d3ff18a766b9f93545d11a5239dc3ae8c6
+  metadata.gz: e52d8e6c8f71d5d4c41362c059e32edb1604d8f63ed7cb13688ea75eaf4d5509
+  data.tar.gz: 4107c6f56a20d397102eb724734ee661d820af2c8b96dae63e72154b40e661f3
 SHA512:
-  metadata.gz: d5e73feba635548e4109cf1c95c62cc1a12a04f46817e2edcc180cd54f0147ca1e200e5a7eb4278fa1a851fcde61ead7e9407b78adcdb81bec85569112733269
-  data.tar.gz: 666785c03ab0fc8d4f21636bc0856669c838ea546c983d8d2d9e41d20ea04e274ae3991261ddcdd101d64aef6db288c6da5c76fa5ec0e1002a61660b0e3f6dc9
+  metadata.gz: 7c69236ddfa00fb917b7c0440539f0cfec3f16d8464fd0cee0293eb8b88a11240bfff4c45b2da83aecb1e3427859473cfe4862189160b15aa376690a3a0b0e16
+  data.tar.gz: 286a89fb6a350273c60d6c85c8082eec0cf51860624244755e81bc375d385863fe21f7c4e50dffd7c0935c875fd72645fa053f3edec7a8fb65a9cad06bdea726

data/.github/workflows/otel.yml

@@ -0,0 +1,48 @@
+name: opentelemetry
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+jobs:
+  test-otel:
+    name: 'Test Open Telemetry'
+    env:
+      TEST_ES_SERVER: http://localhost:9250
+      PORT: 9250
+      TEST_WITH_OTEL: true
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['3.2', 'jruby-9.4']
+        es_version: ['8.9-SNAPSHOT']
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Increase system limits
+        run: |
+          sudo swapoff -a
+          sudo sysctl -w vm.swappiness=1
+          sudo sysctl -w fs.file-max=262144
+          sudo sysctl -w vm.max_map_count=262144
+      - uses: elastic/elastic-github-actions/elasticsearch@master
+        with:
+          stack-version: ${{ matrix.es_version }}
+          security-enabled: false
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Build and test with Rake
+        run: |
+          sudo apt-get update
+          sudo apt-get install libcurl4-openssl-dev
+          ruby -v
+          bundle install
+      - name: unit tests
+        run: bundle exec rake test:unit
+      - name: specs
+        run: bundle exec rake test:spec
+      - name: integration tests
+        run: bundle exec rake test:integration

data/.github/workflows/tests.yml

@@ -1,11 +1,11 @@
-name: 8.2 tests
+name: main tests
 on:
   push:
     branches:
-      - 8.2
+      - main
   pull_request:
     branches:
-      - 8.2
+      - main
 jobs:
   test:
     name: 'Main tests'
@@ -15,8 +15,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '3.0', '3.1', '3.2', '3.3', 'jruby-9.3', 'jruby-9.4' ]
-        es_version: ['8.11-SNAPSHOT', '8.12-SNAPSHOT']
+        ruby: [ '3.0', '3.1', '3.2', 'jruby-9.3', 'jruby-9.4' ]
+        es_version: ['8.9-SNAPSHOT', '8.10-SNAPSHOT', '8.11.0-SNAPSHOT']
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v3
@@ -53,8 +53,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '3.0', '3.1', '3.2', '3.3', 'jruby-9.3' ]
-        es_version: ['8.12-SNAPSHOT']
+        ruby: [ '3.0', '3.1', '3.2', 'jruby-9.3' ]
+        es_version: ['8.9-SNAPSHOT']
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v3

data/CHANGELOG.md

@@ -1,8 +1,8 @@
-## 8.2.5
+## 8.3.0
 
-Tested versions of Ruby: (MRI) 3.0, 3.1, 3.2, 3.3, JRuby 9.3 and JRuby 9.4
+Tested versions of Ruby: (MRI) 3.0, 3.1, 3.2, JRuby 9.3 and JRuby 9.4
 
-- Removes unneccessary `require 'base64'` found thanks to warning in Ruby 3.3. So this removes the warning too if you were using Ruby 3.3.
+This release adds native support for OpenTelemetry. Documentation will be added to [the official Transport documentation](https://www.elastic.co/guide/en/elasticsearch/client/ruby-api/current/transport.html). Pull Request: [#54](https://github.com/elastic/elastic-transport-ruby/pull/54).
 
 ## 8.2.4
 

data/Gemfile

@@ -32,4 +32,7 @@ group :development, :test do
   else
     gem 'pry-byebug'
   end
+  if RUBY_VERSION >= '3.0'
+    gem 'opentelemetry-sdk', require: false
+  end
 end

data/lib/elastic/transport/client.rb

@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
+require 'base64'
 require 'elastic/transport/meta_header'
 
 module Elastic
@@ -163,14 +164,39 @@ module Elastic
                          @transport_class.new(hosts: @hosts, options: @arguments)
                        end
         end
+
+        if defined?(::OpenTelemetry) && ENV[OpenTelemetry::ENV_VARIABLE_ENABLED] != 'false'
+          @otel = OpenTelemetry.new(@arguments)
+        end
       end
 
       # Performs a request through delegation to {#transport}.
       #
-      def perform_request(method, path, params = {}, body = nil, headers = nil)
+      def perform_request(method, path, params = {}, body = nil, headers = nil, opts = {})
         method = @send_get_body_as if 'GET' == method && body
         validate_ca_fingerprints if @ca_fingerprint
-        transport.perform_request(method, path, params, body, headers)
+        if @otel
+          # If no endpoint is specified in the opts, use the HTTP method name
+          span_name = opts[:endpoint] || method
+          @otel.tracer.in_span(span_name) do |span|
+            span['http.request.method'] = method
+            span['db.system'] = 'elasticsearch'
+            opts[:defined_params]&.each do |k, v|
+              if v.respond_to?(:join)
+                span["db.elasticsearch.path_parts.#{k}"] = v.join(',')
+              else
+                span["db.elasticsearch.path_parts.#{k}"] = v
+              end
+            end
+            if body_as_json = @otel.process_body(body, opts[:endpoint])
+              span['db.statement'] = body_as_json
+            end
+            span['db.operation'] = opts[:endpoint] if opts[:endpoint]
+            transport.perform_request(method, path, params || {}, body, headers)
+          end
+        else
+          transport.perform_request(method, path, params || {}, body, headers)
+        end
       end
 
       private

data/lib/elastic/transport/meta_header.rb

@@ -15,6 +15,8 @@
 # specific language governing permissions and limitations
 # under the License.
 
+require 'base64'
+
 module Elastic
   module Transport
     # Methods for the Elastic meta header used by Cloud.

data/lib/elastic/transport/opentelemetry.rb

@@ -0,0 +1,157 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Elastic
+  module Transport
+    # Wrapper object for Open Telemetry objects, associated config and functionality.
+    #
+    # @api private
+    class OpenTelemetry
+      OTEL_TRACER_NAME = 'elasticsearch-api'
+      # Valid values for the enabled config are 'true' and 'false'. Default is 'true'.
+      ENV_VARIABLE_ENABLED = 'OTEL_RUBY_INSTRUMENTATION_ELASTICSEARCH_ENABLED'
+      # Describes how to handle search queries in the request body when assigned to
+      # a span attribute.
+      # Valid values are 'raw', 'omit', 'sanitize'. Default is 'omit'.
+      ENV_VARIABLE_BODY_STRATEGY = 'OTEL_INSTRUMENTATION_ELASTICSEARCH_CAPTURE_SEARCH_QUERY'
+      DEFAULT_BODY_STRATEGY = 'omit'
+      # A string list of keys whose values are redacted. This is only relevant if the body strategy is
+      # 'sanitize'. For example, a config 'sensitive-key,other-key' will redact the values at
+      # 'sensitive-key' and 'other-key' in addition to the default keys.
+      ENV_VARIABLE_BODY_SANITIZE_KEYS = 'OTEL_RUBY_INSTRUMENTATION_ELASTICSEARCH_SEARCH_QUERY_SANITIZE_KEYS'
+
+      # A list of the Elasticsearch endpoints that qualify as "search" endpoints. The search query in
+      # the request body may be captured for these endpoints, depending on the body capture strategy.
+      SEARCH_ENDPOINTS = Set[
+        "search",
+        "async_search.submit",
+        "msearch",
+        "eql.search",
+        "terms_enum",
+        "search_template",
+        "msearch_template",
+        "render_search_template",
+      ]
+
+      # Initialize the Open Telemetry wrapper object. Takes the options originally passed to
+      # Client#initialize.
+      def initialize(opts)
+        @tracer = (opts[:opentelemetry_tracer_provider] || ::OpenTelemetry.tracer_provider).tracer(
+          OTEL_TRACER_NAME, Elastic::Transport::VERSION
+        )
+        @body_strategy = ENV[ENV_VARIABLE_BODY_STRATEGY] || DEFAULT_BODY_STRATEGY
+        @sanitize_keys = ENV[ENV_VARIABLE_BODY_SANITIZE_KEYS]&.split(',')&.collect! do |pattern|
+          Regexp.new(pattern.gsub('*', '.*'))
+        end
+      end
+      attr_accessor :tracer
+
+      # Process the request body. Applies the body strategy, which can be one of the following:
+      # 'omit': return nil
+      # 'sanitize': redact values at the default list of keys + any additional keys provided in
+      # the OTEL_RUBY_INSTRUMENTATION_ELASTICSEARCH_SEARCH_QUERY_SANITIZE_KEYS env variable.
+      # 'raw': return the original body, unchanged
+      def process_body(body, endpoint)
+        unless @body_strategy == 'omit' || !SEARCH_ENDPOINTS.include?(endpoint)
+          if @body_strategy == 'sanitize'
+            Sanitizer.sanitize(body, @sanitize_keys).to_json
+          elsif @body_strategy == 'raw'
+            body&.is_a?(String) ? body : body.to_json
+          end
+        end
+      end
+
+      # Replaces values in a hash with 'REDACTED', given a set of keys to match on.
+      class Sanitizer
+        class << self
+          FILTERED = 'REDACTED'
+          DEFAULT_KEY_PATTERNS =
+            %w[password passwd pwd secret *key *token* *session* *credit* *card* *auth* set-cookie].map! do |p|
+              Regexp.new(p.gsub('*', '.*'))
+            end
+
+          def sanitize(body, key_patterns = [])
+            patterns = DEFAULT_KEY_PATTERNS
+            patterns += key_patterns if key_patterns
+            sanitize!(DeepDup.dup(body), patterns)
+          end
+
+          private
+
+          def sanitize!(obj, key_patterns)
+            return obj unless obj.is_a?(Hash)
+
+            obj.each_pair do |k, v|
+              if filter_key?(key_patterns, k)
+                obj[k] = FILTERED
+              elsif v.is_a?(Hash)
+                sanitize!(v, key_patterns)
+              else
+                next
+              end
+            end
+          end
+
+          def filter_key?(key_patterns, key)
+            key_patterns.any? { |regex| regex.match(key) }
+          end
+        end
+      end
+
+      # Makes a deep copy of an Array or Hash
+      # NB: Not guaranteed to work well with complex objects, only simple Hash,
+      # Array, String, Number, etc.
+      class DeepDup
+        def initialize(obj)
+          @obj = obj
+        end
+
+        def dup
+          deep_dup(@obj)
+        end
+
+        def self.dup(obj)
+          new(obj).dup
+        end
+
+        private
+
+        def deep_dup(obj)
+          case obj
+          when Hash then hash(obj)
+          when Array then array(obj)
+          else obj.dup
+          end
+        end
+
+        def array(arr)
+          arr.map { |obj| deep_dup(obj) }
+        end
+
+        def hash(hsh)
+          result = hsh.dup
+
+          hsh.each_pair do |key, value|
+            result[key] = deep_dup(value)
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -471,6 +471,14 @@ module Elastic
             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/http/curb.rb

@@ -31,7 +31,8 @@ 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)

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

@@ -34,6 +34,7 @@ module Elastic
           #
           def perform_request(method, path, params = {}, body = nil, headers = nil, opts = {})
             super do |connection, url|
+              capture_otel_span_attributes(connection, url)
               headers = parse_headers(headers, connection)
               body = body ? __convert_to_json(body) : nil
               body, headers = compress_request(body, headers)

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

@@ -89,6 +89,7 @@ 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, parse_headers(headers))
               params[:body] = body if body

data/lib/elastic/transport/version.rb

@@ -17,6 +17,6 @@
 
 module Elastic
   module Transport
-    VERSION = '8.2.5'.freeze
+    VERSION = '8.3.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'

data/spec/elastic/transport/opentelemetry_spec.rb

@@ -0,0 +1,306 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'spec_helper'
+
+if defined?(::OpenTelemetry)
+  describe Elastic::Transport::OpenTelemetry do
+    let(:exporter) { EXPORTER }
+    before { exporter.reset }
+    after { exporter.reset }
+    let(:span) { exporter.finished_spans[0] }
+
+    let(:client) do
+      Elastic::Transport::Client.new(hosts: ELASTICSEARCH_HOSTS).tap do |_client|
+        allow(_client).to receive(:__build_connections)
+      end
+    end
+
+    let(:otel) { described_class.new }
+
+    context 'when the client is created with a tracer provider' do
+      let(:tracer_provider) do
+        double('tracer_provider').tap do |tp|
+          expect(tp).to receive(:tracer).with(
+            Elastic::Transport::OpenTelemetry::OTEL_TRACER_NAME, Elastic::Transport::VERSION
+          )
+        end
+      end
+
+      it 'uses the tracer provider to get a tracer' do
+        Elastic::Transport::Client.new(opentelemetry_tracer_provider: tracer_provider)
+      end
+    end
+
+    context 'when path parameters' do
+      before do
+        client.perform_request('DELETE', '/users', nil, nil, nil)
+      rescue
+      end
+      after do
+        client.perform_request('DELETE', '/users', nil, nil, nil)
+      rescue
+      end
+
+      it 'creates a span with path parameters' do
+        client.perform_request(
+          'POST', '/users/_create/abc', nil, { name: 'otel-test' }, nil,
+          defined_params: {'index' => 'users', 'id' => 'abc'}, endpoint: 'create'
+        )
+
+        span = exporter.finished_spans.find { |s| s.name == 'create' }
+        expect(span.name).to eql('create')
+        expect(span.attributes['db.system']).to eql('elasticsearch')
+        expect(span.attributes['db.elasticsearch.path_parts.index']).to eql('users')
+        expect(span.attributes['db.elasticsearch.path_parts.id']).to eq('abc')
+        expect(span.attributes['db.operation']).to eq('create')
+        expect(span.attributes['db.statement']).to be_nil
+        expect(span.attributes['http.request.method']).to eq('POST')
+        expect(span.attributes['server.address']).to eq('localhost')
+        expect(span.attributes['server.port']).to eq(TEST_PORT.to_i)
+      end
+
+      context 'with list a path parameter' do
+        it 'creates a span with path parameters' do
+          client.perform_request(
+            'GET', '_cluster/state/foo,bar', {}, nil, {},
+            { defined_params: { metric: ['foo', 'bar']}, endpoint: 'cluster.state' }
+          )
+
+          span = exporter.finished_spans.find { |s| s.name == 'cluster.state' }
+          expect(span.name).to eql('cluster.state')
+          expect(span.attributes['db.system']).to eql('elasticsearch')
+          expect(span.attributes['db.elasticsearch.path_parts.metric']).to eql('foo,bar')
+          expect(span.attributes['db.operation']).to eq('cluster.state')
+          expect(span.attributes['db.statement']).to be_nil
+          expect(span.attributes['http.request.method']).to eq('GET')
+          expect(span.attributes['server.address']).to eq('localhost')
+          expect(span.attributes['server.port']).to eq(TEST_PORT.to_i)
+        end
+      end
+    end
+
+    context 'when a request is instrumented' do
+      let(:body) do
+        { query: { match: { password: { query: 'secret'} } } }
+      end
+
+      it 'creates a span and omits db.statement' do
+        client.perform_request('GET', '/_search', nil, body, nil, endpoint: 'search')
+
+        expect(span.name).to eql('search')
+        expect(span.attributes['db.system']).to eql('elasticsearch')
+        expect(span.attributes['db.operation']).to eq('search')
+        expect(span.attributes['db.statement']).to be_nil
+        expect(span.attributes['http.request.method']).to eq('GET')
+        expect(span.attributes['server.address']).to eq('localhost')
+        expect(span.attributes['server.port']).to eq(TEST_PORT.to_i)
+      end
+
+      context 'when body is sanitized' do
+        context 'no custom keys' do
+          let(:sanitized_body) do
+            { query: { match: { password: 'REDACTED' } } }
+          end
+
+          around(:example) do |ex|
+            body_strategy = ENV[described_class::ENV_VARIABLE_BODY_STRATEGY]
+            ENV[described_class::ENV_VARIABLE_BODY_STRATEGY]  = 'sanitize'
+            ex.run
+            ENV[described_class::ENV_VARIABLE_BODY_STRATEGY] = body_strategy
+          end
+
+          it 'sanitizes the body' do
+            client.perform_request('GET', '/_search', nil, body, nil, endpoint: 'search')
+
+            expect(span.attributes['db.statement']).to eq(sanitized_body.to_json)
+          end
+        end
+
+        context 'with custom keys' do
+          let(:body) do
+            { query: { match: { sensitive: { query: 'secret'} } } }
+          end
+
+          let(:sanitized_body) do
+            { query: { match: { sensitive: 'REDACTED' } } }
+          end
+
+          around(:example) do |ex|
+            body_strategy = ENV[described_class::ENV_VARIABLE_BODY_STRATEGY]
+            ENV[described_class::ENV_VARIABLE_BODY_STRATEGY] = 'sanitize'
+
+            keys = ENV[described_class::ENV_VARIABLE_BODY_SANITIZE_KEYS]
+            ENV[described_class::ENV_VARIABLE_BODY_SANITIZE_KEYS] = 'sensitive'
+
+            ex.run
+
+            ENV[described_class::ENV_VARIABLE_BODY_STRATEGY] = body_strategy
+            ENV[described_class::ENV_VARIABLE_BODY_SANITIZE_KEYS] = keys
+          end
+
+          it 'sanitizes the body' do
+            client.perform_request('GET', '/_search', nil, body, nil, endpoint: 'search')
+
+            expect(span.attributes['db.statement']).to eq(sanitized_body.to_json)
+          end
+        end
+      end
+
+      context 'when body strategy is set to raw' do
+        let(:body) do
+          { query: { match: { sensitive: { query: 'secret'} } } }
+        end
+
+        around(:example) do |ex|
+          body_strategy = ENV[described_class::ENV_VARIABLE_BODY_STRATEGY]
+          ENV[described_class::ENV_VARIABLE_BODY_STRATEGY]  = 'raw'
+          ex.run
+          ENV[described_class::ENV_VARIABLE_BODY_STRATEGY] = body_strategy
+        end
+
+        context 'when the body is a string' do
+          it 'includes the raw body' do
+            client.perform_request('GET', '/_search', nil, body.to_json, nil, endpoint: 'search')
+            expect(span.attributes['db.statement']).to eq(body.to_json)
+          end
+        end
+
+        context' when the body is a hash' do
+          it 'includes the raw body' do
+            client.perform_request('GET', '/_search', nil, body, nil, endpoint: 'search')
+            expect(span.attributes['db.statement']).to eq(body.to_json)
+          end
+        end
+      end
+
+      context 'when body strategy is set to omit' do
+        let(:body) do
+          { query: { match: { sensitive: { query: 'secret'} } } }
+        end
+
+        around(:example) do |ex|
+          body_strategy = ENV[described_class::ENV_VARIABLE_BODY_STRATEGY]
+          ENV[described_class::ENV_VARIABLE_BODY_STRATEGY]  = 'omit'
+          ex.run
+          ENV[described_class::ENV_VARIABLE_BODY_STRATEGY] = body_strategy
+        end
+
+        it 'does not include anything' do
+          client.perform_request('GET', '/_search', nil, body, nil, endpoint: 'search')
+          expect(span.attributes['db.statement']).to be_nil
+        end
+      end
+
+      context 'a non-search endpoint' do
+        let(:body) do
+          { query: { match: { something: "test" } } }
+        end
+
+        it 'does not capture db.statement' do
+          client.perform_request(
+            'POST', '_all/_delete_by_query', nil, body, nil, endpoint: 'delete_by_query'
+          )
+
+          expect(span.attributes['db.statement']).to be_nil
+        end
+      end
+
+      context 'when no endpoint or defined params are provided' do
+        it 'creates a span with default values' do
+          client.perform_request(
+            'GET', '_cluster/state/foo,bar', {}, nil, {}
+          )
+
+          span = exporter.finished_spans.find { |s| s.name == 'GET' }
+          expect(span.name).to eql('GET')
+          expect(span.attributes['db.system']).to eql('elasticsearch')
+          expect(span.attributes['db.elasticsearch.path_parts']).to be_nil
+          expect(span.attributes['db.operation']).to be_nil
+          expect(span.attributes['db.statement']).to be_nil
+          expect(span.attributes['http.request.method']).to eq('GET')
+          expect(span.attributes['server.address']).to eq('localhost')
+          expect(span.attributes['server.port']).to eq(TEST_PORT.to_i)
+        end
+      end
+    end
+
+    context 'when the ENV variable OTEL_RUBY_INSTRUMENTATION_ELASTICSEARCH_ENABLED is set' do
+      context 'to true' do
+        around do |ex|
+          original_setting = ENV[described_class::ENV_VARIABLE_ENABLED]
+          ENV[described_class::ENV_VARIABLE_ENABLED] = 'true'
+          ex.run
+          ENV[described_class::ENV_VARIABLE_ENABLED] = original_setting
+        end
+
+        it 'instruments' do
+          client.perform_request('GET', '/_search', nil, nil, nil, endpoint: 'search')
+          expect(span.name).to eq('search')
+        end
+      end
+
+      context 'to false' do
+        around do |ex|
+          original_setting = ENV[described_class::ENV_VARIABLE_ENABLED]
+          ENV[described_class::ENV_VARIABLE_ENABLED] = 'false'
+          ex.run
+          ENV[described_class::ENV_VARIABLE_ENABLED] = original_setting
+        end
+
+        it 'does not instrument' do
+          client.perform_request('GET', '/_search', nil, nil, nil, endpoint: 'search')
+          expect(span).to be_nil
+        end
+      end
+    end
+
+    describe Elastic::Transport::OpenTelemetry::Sanitizer do
+      let(:key_patterns) { nil }
+
+      context '#sanitize' do
+        let(:body) do
+          { query: { match: { password: "test" } } }
+        end
+
+        let(:expected_body) do
+          { query: { match: { password: "REDACTED" } } }
+        end
+
+        it 'redacts sensitive values' do
+          expect(described_class.sanitize(body, key_patterns)).to eq(expected_body)
+        end
+
+        context 'with specified key patterns' do
+          let(:key_patterns) { [/something/] }
+
+          let(:body) do
+            { query: { match: { something: "test" } } }
+          end
+
+          let(:expected_body) do
+            { query: { match: { something: "REDACTED" } } }
+          end
+
+          it 'redacts sensitive values' do
+            expect(described_class.sanitize(body, key_patterns)).to eq(expected_body)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -91,3 +91,15 @@ RSpec.configure do |config|
   config.formatter = 'documentation'
   config.color = true
 end
+
+if ENV['TEST_WITH_OTEL'] == 'true'
+  require 'opentelemetry-sdk'
+  EXPORTER = OpenTelemetry::SDK::Trace::Export::InMemorySpanExporter.new
+  span_processor = OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(EXPORTER)
+
+  OpenTelemetry::SDK.configure do |c|
+    c.error_handler = ->(exception:, message:) { raise(exception || message) }
+    c.logger = Logger.new($stderr, level: ENV.fetch('OTEL_LOG_LEVEL', 'fatal').to_sym)
+    c.add_span_processor span_processor
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elastic-transport
 version: !ruby/object:Gem::Version
-  version: 8.2.5
+  version: 8.3.0
 platform: ruby
 authors:
 - Elastic Client Library Maintainers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-24 00:00:00.000000000 Z
+date: 2023-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -263,6 +263,7 @@ files:
 - ".github/check_license_headers.rb"
 - ".github/license-header.txt"
 - ".github/workflows/license.yml"
+- ".github/workflows/otel.yml"
 - ".github/workflows/tests.yml"
 - ".gitignore"
 - CHANGELOG.md
@@ -277,6 +278,7 @@ files:
 - lib/elastic/transport.rb
 - lib/elastic/transport/client.rb
 - lib/elastic/transport/meta_header.rb
+- lib/elastic/transport/opentelemetry.rb
 - lib/elastic/transport/redacted.rb
 - lib/elastic/transport/transport/base.rb
 - lib/elastic/transport/transport/connections/collection.rb
@@ -299,6 +301,7 @@ files:
 - spec/elastic/transport/http/faraday_spec.rb
 - spec/elastic/transport/http/manticore_spec.rb
 - spec/elastic/transport/meta_header_spec.rb
+- spec/elastic/transport/opentelemetry_spec.rb
 - spec/elastic/transport/sniffer_spec.rb
 - spec/spec_helper.rb
 - test/integration/jruby_test.rb
@@ -337,7 +340,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
 summary: Low level Ruby client for Elastic services.
@@ -350,6 +353,7 @@ test_files:
 - spec/elastic/transport/http/faraday_spec.rb
 - spec/elastic/transport/http/manticore_spec.rb
 - spec/elastic/transport/meta_header_spec.rb
+- spec/elastic/transport/opentelemetry_spec.rb
 - spec/elastic/transport/sniffer_spec.rb
 - spec/spec_helper.rb
 - test/integration/jruby_test.rb