elastic-transport 8.0.0 → 8.4.0

data/spec/elastic/transport/opentelemetry_spec.rb

@@ -0,0 +1,325 @@
+# 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 deprecated ENV variable' do
+          let(:sanitized_body) do
+            { query: { match: { password: 'REDACTED' } } }
+          end
+
+          around(:example) do |ex|
+            body_strategy = ENV[described_class::ENV_VARIABLE_DEPRECATED_BODY_STRATEGY]
+            ENV[described_class::ENV_VARIABLE_DEPRECATED_BODY_STRATEGY]  = 'sanitize'
+            ex.run
+            ENV[described_class::ENV_VARIABLE_DEPRECATED_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/elastic/transport/sniffer_spec.rb

@@ -257,6 +257,24 @@ describe Elastic::Transport::Transport::Sniffer do
       end
     end
 
+    context 'when the address is IPv4' do
+      let(:publish_address) do
+        'inet[/127.0.0.1:9200]'
+      end
+
+      it 'parses the response' do
+        expect(hosts.size).to eq(1)
+      end
+
+      it 'correctly parses the host' do
+        expect(hosts[0][:host]).to eq('127.0.0.1')
+      end
+
+      it 'correctly parses the port' do
+        expect(hosts[0][:port]).to eq('9200')
+      end
+    end
+
     context 'when the transport has :randomize_hosts option' do
       let(:raw_response) do
         { 'nodes' => { 'n1' => { 'http' => { 'publish_address' => '127.0.0.1:9250' } },

data/spec/spec_helper.rb

@@ -21,7 +21,6 @@ end
 
 require 'elastic-transport'
 require 'logger'
-require 'ansi/code'
 require 'hashie/mash'
 if defined?(JRUBY_VERSION)
   require 'elastic/transport/transport/http/manticore'
@@ -74,6 +73,10 @@ def default_client
   $client ||= Elastic::Transport::Client.new(hosts: ELASTICSEARCH_HOSTS)
 end
 
+def is_faraday_v2?
+  Gem::Version.new(Faraday::VERSION) >= Gem::Version.new(2)
+end
+
 module Config
   def self.included(context)
     # Get the hosts to use to connect an elasticsearch client.
@@ -88,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

data/test/integration/jruby_test.rb

@@ -21,7 +21,7 @@ if JRUBY
   require 'elastic/transport/transport/http/manticore'
 
   class Elastic::Transport::ClientManticoreIntegrationTest < Minitest::Test
-    context "Transport" do
+    context 'Transport' do
       setup do
         uri = URI(HOST)
         @host = {

data/test/integration/transport_test.rb

@@ -18,9 +18,8 @@
 require 'test_helper'
 
 class Elastic::Transport::ClientIntegrationTest < Minitest::Test
-  context "Transport" do
+  context 'Transport' do
     setup do
-      begin; Object.send(:remove_const, :Patron);   rescue NameError; end
       uri = URI(HOST)
       @host = {
         host: uri.host,
@@ -30,69 +29,116 @@ class Elastic::Transport::ClientIntegrationTest < Minitest::Test
       }
     end
 
-    should "allow to customize the Faraday adapter to Typhoeus" do
-      require 'typhoeus'
-      require 'typhoeus/adapters/faraday'
-
+    should 'use the default Faraday adapter' do
       transport = Elastic::Transport::Transport::HTTP::Faraday.new(hosts: [@host]) do |f|
         f.response :logger
-        f.adapter  :typhoeus
       end
 
       client = Elastic::Transport::Client.new(transport: transport)
+      assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::NetHttp)
       client.perform_request 'GET', ''
-    end unless jruby?
+    end
 
-    should "allow to customize the Faraday adapter to NetHttpPersistent" do
-      require 'net/http/persistent'
+    unless jruby?
+      should 'allow to customize the Faraday adapter to Typhoeus' do
+        if is_faraday_v2?
+          require 'faraday/typhoeus'
+        else
+          require 'typhoeus'
+        end
+
+        transport = Elastic::Transport::Transport::HTTP::Faraday.new(hosts: [@host]) do |f|
+          f.response :logger
+          f.adapter  :typhoeus
+        end
+
+        client = Elastic::Transport::Client.new(transport: transport)
+        assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::Typhoeus)
+        client.perform_request 'GET', ''
+      end
 
-      transport = Elastic::Transport::Transport::HTTP::Faraday.new(hosts: [@host]) do |f|
-        f.response :logger
-        f.adapter  :net_http_persistent
+      should 'use the Curb client' do
+        require 'curb'
+        require 'elastic/transport/transport/http/curb'
+
+        transport = Elastic::Transport::Transport::HTTP::Curb.new(hosts: [@host]) do |curl|
+          curl.verbose = true
+        end
+
+        client = Elastic::Transport::Client.new(transport: transport)
+        assert_equal(client.transport.class, Elastic::Transport::Transport::HTTP::Curb)
+        client.perform_request 'GET', ''
       end
 
-      client = Elastic::Transport::Client.new(transport: transport)
-      client.perform_request 'GET', ''
-    end
+      should 'deserialize JSON responses in the Curb client' do
+        require 'curb'
+        require 'elastic/transport/transport/http/curb'
 
-    should "allow to define connection parameters and pass them" do
-      transport = Elastic::Transport::Transport::HTTP::Faraday.new(
-        hosts: [@host],
-        options: { transport_options: { params: { format: 'yaml' } } }
-      )
+        transport = Elastic::Transport::Transport::HTTP::Curb.new(hosts: [@host]) do |curl|
+          curl.verbose = true
+        end
 
-      client = Elastic::Transport::Client.new transport: transport
-      response = client.perform_request 'GET', ''
+        client = Elastic::Transport::Client.new(transport: transport)
+        response = client.perform_request 'GET', ''
 
-      assert response.body.start_with?("---\n"), "Response body should be YAML: #{response.body.inspect}"
+        assert_respond_to(response.body, :to_hash)
+        assert_not_nil response.body['name']
+        assert_equal 'application/json', response.headers['content-type']
+        assert_equal 'Elasticsearch', response.headers['x-elastic-product']
+      end
+
+      should 'allow to customize the Faraday adapter to Patron' do
+        if is_faraday_v2?
+          require 'faraday/patron'
+        else
+          require 'patron'
+        end
+        transport = Elastic::Transport::Transport::HTTP::Faraday.new(hosts: [@host]) do |f|
+          f.response :logger
+          f.adapter  :patron
+        end
+
+        client = Elastic::Transport::Client.new(transport: transport)
+        assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::Patron)
+        client.perform_request 'GET', ''
+      end
     end
 
-    should "use the Curb client" do
-      require 'curb'
-      require 'elastic/transport/transport/http/curb'
+    should 'allow to customize the Faraday adapter to NetHttpPersistent' do
+      require 'faraday/net_http_persistent'
 
-      transport = Elastic::Transport::Transport::HTTP::Curb.new(hosts: [@host]) do |curl|
-        curl.verbose = true
+      transport = Elastic::Transport::Transport::HTTP::Faraday.new(hosts: [@host]) do |f|
+        f.response :logger
+        f.adapter  :net_http_persistent
       end
 
       client = Elastic::Transport::Client.new(transport: transport)
+      assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::NetHttpPersistent)
       client.perform_request 'GET', ''
-    end unless JRUBY
+    end
 
-    should "deserialize JSON responses in the Curb client" do
-      require 'curb'
-      require 'elastic/transport/transport/http/curb'
+    should 'allow to customize the Faraday adapter to HTTPClient' do
+      require 'faraday/httpclient'
 
-      transport = Elastic::Transport::Transport::HTTP::Curb.new(hosts: [@host]) do |curl|
-        curl.verbose = true
+      transport = Elastic::Transport::Transport::HTTP::Faraday.new(hosts: [@host]) do |f|
+        f.response :logger
+        f.adapter  :httpclient
       end
 
       client = Elastic::Transport::Client.new(transport: transport)
-      response = client.perform_request 'GET', ''
+      assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::HTTPClient)
+      client.perform_request 'GET', ''
+    end
 
-      assert_respond_to(response.body, :to_hash)
-      assert_not_nil response.body['name']
-      assert_equal 'application/json', response.headers['content-type']
-    end unless jruby?
+    should 'allow to define connection parameters and pass them' do
+      transport = Elastic::Transport::Transport::HTTP::Faraday.new(
+        hosts: [@host],
+        options: { transport_options: { params: { format: 'yaml' } } }
+      )
+
+      client = Elastic::Transport::Client.new transport: transport
+      response = client.perform_request 'GET', ''
+      assert response.body.start_with?("---\n"), "Response body should be YAML: #{response.body.inspect}"
+    end
   end
 end

data/test/test_helper.rb

@@ -14,6 +14,7 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
+require 'uri'
 
 password = ENV['ELASTIC_PASSWORD'] || 'changeme'
 host = ENV['TEST_ES_SERVER'] || 'http://localhost:9200'
@@ -31,15 +32,13 @@ end
 
 require 'minitest/autorun'
 require 'minitest/reporters'
-require 'shoulda/context'
 require 'mocha/minitest'
-require 'ansi/code'
+require 'shoulda/context'
 
-require 'require-prof' if ENV["REQUIRE_PROF"]
 require 'elastic-transport'
-require 'logger'
-
 require 'hashie'
+require 'logger'
+require 'require-prof' if ENV["REQUIRE_PROF"]
 
 RequireProf.print_timing_infos if ENV["REQUIRE_PROF"]
 
@@ -80,4 +79,8 @@ module Minitest
   end
 end
 
-Minitest::Reporters.use! FixedMinitestSpecReporter.new
+def is_faraday_v2?
+  Gem::Version.new(Faraday::VERSION) >= Gem::Version.new(2)
+end
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new(print_failure_summary: true)