couchbase 3.7.0-aarch64-linux → 3.8.0-aarch64-linux

data/lib/couchbase/management/query_index_manager.rb

@@ -385,8 +385,12 @@ module Couchbase
       alias inspect to_s
 
       # @param [Couchbase::Backend] backend
-      def initialize(backend)
+      # @param [Couchbase::Observability::Wrapper] observability wrapper
+      #
+      # @api private
+      def initialize(backend, observability)
         @backend = backend
+        @observability = observability
       end
 
       # Fetches all indexes from the server
@@ -402,19 +406,25 @@ module Couchbase
           warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
         end
 
-        res = @backend.query_index_get_all(bucket_name, options.to_backend)
-        res[:indexes].map do |idx|
-          QueryIndex.new do |index|
-            index.name = idx[:name]
-            index.is_primary = idx[:is_primary]
-            index.type = idx[:type]
-            index.state = idx[:state]
-            index.bucket = idx[:bucket_name]
-            index.scope = idx[:scope_name]
-            index.collection = idx[:collection_name]
-            index.index_key = idx[:index_key]
-            index.condition = idx[:condition]
-            index.partition = idx[:partition]
+        @observability.record_operation(Observability::OP_QM_GET_ALL_INDEXES, options.parent_span, self, :query) do |obs_handler|
+          obs_handler.add_bucket_name(bucket_name)
+          obs_handler.add_scope_name(options.scope_name) unless options.scope_name.nil?
+          obs_handler.add_collection_name(options.collection_name) unless options.collection_name.nil?
+
+          res = @backend.query_index_get_all(bucket_name, options.to_backend, obs_handler)
+          res[:indexes].map do |idx|
+            QueryIndex.new do |index|
+              index.name = idx[:name]
+              index.is_primary = idx[:is_primary]
+              index.type = idx[:type]
+              index.state = idx[:state]
+              index.bucket = idx[:bucket_name]
+              index.scope = idx[:scope_name]
+              index.collection = idx[:collection_name]
+              index.index_key = idx[:index_key]
+              index.condition = idx[:condition]
+              index.partition = idx[:partition]
+            end
           end
         end
       end
@@ -435,7 +445,13 @@ module Couchbase
           warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
         end
 
-        @backend.query_index_create(bucket_name, index_name, fields, options.to_backend)
+        @observability.record_operation(Observability::OP_QM_CREATE_INDEX, options.parent_span, self, :query) do |obs_handler|
+          obs_handler.add_bucket_name(bucket_name)
+          obs_handler.add_scope_name(options.scope_name) unless options.scope_name.nil?
+          obs_handler.add_collection_name(options.collection_name) unless options.collection_name.nil?
+
+          @backend.query_index_create(bucket_name, index_name, fields, options.to_backend, obs_handler)
+        end
       end
 
       # Creates new primary index
@@ -452,7 +468,13 @@ module Couchbase
           warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
         end
 
-        @backend.query_index_create_primary(bucket_name, options.to_backend)
+        @observability.record_operation(Observability::OP_QM_CREATE_PRIMARY_INDEX, options.parent_span, self, :query) do |obs_handler|
+          obs_handler.add_bucket_name(bucket_name)
+          obs_handler.add_scope_name(options.scope_name) unless options.scope_name.nil?
+          obs_handler.add_collection_name(options.collection_name) unless options.collection_name.nil?
+
+          @backend.query_index_create_primary(bucket_name, options.to_backend, obs_handler)
+        end
       end
 
       # Drops the index
@@ -470,7 +492,13 @@ module Couchbase
           warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
         end
 
-        @backend.query_index_drop(bucket_name, index_name, options.to_backend)
+        @observability.record_operation(Observability::OP_QM_DROP_INDEX, options.parent_span, self, :query) do |obs_handler|
+          obs_handler.add_bucket_name(bucket_name)
+          obs_handler.add_scope_name(options.scope_name) unless options.scope_name.nil?
+          obs_handler.add_collection_name(options.collection_name) unless options.collection_name.nil?
+
+          @backend.query_index_drop(bucket_name, index_name, options.to_backend, obs_handler)
+        end
       end
 
       # Drops the primary index
@@ -487,7 +515,13 @@ module Couchbase
           warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
         end
 
-        @backend.query_index_drop_primary(bucket_name, options.to_backend)
+        @observability.record_operation(Observability::OP_QM_DROP_PRIMARY_INDEX, options.parent_span, self, :query) do |obs_handler|
+          obs_handler.add_bucket_name(bucket_name)
+          obs_handler.add_scope_name(options.scope_name) unless options.scope_name.nil?
+          obs_handler.add_collection_name(options.collection_name) unless options.collection_name.nil?
+
+          @backend.query_index_drop_primary(bucket_name, options.to_backend, obs_handler)
+        end
       end
 
       # Build all indexes which are currently in deferred state
@@ -503,7 +537,13 @@ module Couchbase
           warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
         end
 
-        @backend.query_index_build_deferred(bucket_name, options.to_backend)
+        @observability.record_operation(Observability::OP_QM_BUILD_DEFERRED_INDEXES, options.parent_span, self, :query) do |obs_handler|
+          obs_handler.add_bucket_name(bucket_name)
+          obs_handler.add_scope_name(options.scope_name) unless options.scope_name.nil?
+          obs_handler.add_collection_name(options.collection_name) unless options.collection_name.nil?
+
+          @backend.query_index_build_deferred(bucket_name, options.to_backend, obs_handler)
+        end
       end
 
       # Polls indexes until they are online
@@ -520,24 +560,36 @@ module Couchbase
           warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
         end
 
-        index_names.append("#primary") if options.watch_primary
-
-        interval_millis = 50
-        deadline = Time.now + (Utils::Time.extract_duration(timeout) * 0.001)
-        while Time.now <= deadline
-          get_all_opts = Options::Query::GetAllIndexes.new(timeout: ((deadline - Time.now) * 1000).round)
-          indexes = get_all_indexes(bucket_name, get_all_opts).select { |idx| index_names.include? idx.name }
-          indexes_not_found = index_names - indexes.map(&:name)
-          raise Error::IndexNotFound, "Failed to find the indexes: #{indexes_not_found.join(', ')}" unless indexes_not_found.empty?
-
-          all_online = indexes.all? { |idx| idx.state == :online }
-          return if all_online
-
-          sleep(interval_millis / 1000)
-          interval_millis += 500
-          interval_millis = 1000 if interval_millis > 1000
+        @observability.record_operation(Observability::OP_QM_WATCH_INDEXES, options.parent_span, self, :query) do |obs_handler|
+          obs_handler.add_bucket_name(bucket_name)
+          obs_handler.add_scope_name(options.scope_name) unless options.scope_name.nil?
+          obs_handler.add_collection_name(options.collection_name) unless options.collection_name.nil?
+
+          index_names.append("#primary") if options.watch_primary
+
+          interval_millis = 50
+          deadline = Time.now + (Utils::Time.extract_duration(timeout) * 0.001)
+          all_online = false
+          while Time.now <= deadline
+            get_all_opts = Options::Query::GetAllIndexes.new(
+              timeout: ((deadline - Time.now) * 1000).round,
+              scope_name: options.scope_name,
+              collection_name: options.collection_name,
+              parent_span: obs_handler.op_span,
+            )
+            indexes = get_all_indexes(bucket_name, get_all_opts).select { |idx| index_names.include? idx.name }
+            indexes_not_found = index_names - indexes.map(&:name)
+            raise Error::IndexNotFound, "Failed to find the indexes: #{indexes_not_found.join(', ')}" unless indexes_not_found.empty?
+
+            all_online = indexes.all? { |idx| idx.state == :online }
+            break if all_online
+
+            sleep(interval_millis / 1000)
+            interval_millis += 500
+            interval_millis = 1000 if interval_millis > 1000
+          end
+          raise Error::UnambiguousTimeout, "Failed to find all indexes online within the allotted time" unless all_online
         end
-        raise Error::UnambiguousTimeout, "Failed to find all indexes online within the allotted time"
       end
 
       # @api private

data/lib/couchbase/management/scope_search_index_manager.rb

@@ -14,6 +14,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+require_relative "search_index_manager"
+
 module Couchbase
   module Management
     class ScopeSearchIndexManager
@@ -22,179 +24,244 @@ module Couchbase
       # @param [Couchbase::Backend] backend
       # @param [String] bucket_name
       # @param [String] scope_name
-      def initialize(backend, bucket_name, scope_name)
+      # @param [Couchbase::Observability::Wrapper] observability wrapper
+      def initialize(backend, bucket_name, scope_name, observability)
         @backend = backend
         @bucket_name = bucket_name
         @scope_name = scope_name
+        @observability = observability
       end
 
       # Fetches an index from the server if it exists
       #
       # @param [String] index_name name of the index
-      # @param [GetIndexOptions] options
+      # @param [Options::Search::GetIndex] options
       #
       # @return [SearchIndex]
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def get_index(index_name, options = GetIndexOptions.new)
-        res = @backend.search_index_get(@bucket_name, @scope_name, index_name, options.timeout)
-        SearchIndexManager.extract_search_index(res)
+      def get_index(index_name, options = Options::Search::GetIndex::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_GET_INDEX, options.parent_span, self, :search) do |obs_handler|
+          res = @backend.search_index_get(@bucket_name, @scope_name, index_name, options.timeout, obs_handler)
+          SearchIndexManager.extract_search_index(res)
+        end
       end
 
       # Fetches all indexes from the server
       #
-      # @param [GetAllIndexesOptions] options
+      # @param [Options::Search::GetAllIndexes] options
       #
       # @return [Array<SearchIndex>]
-      def get_all_indexes(options = GetAllIndexesOptions.new)
-        res = @backend.search_index_get_all(@bucket_name, @scope_name, options.timeout)
-        res[:indexes].map { |idx| SearchIndexManager.extract_search_index(idx) }
+      def get_all_indexes(options = Options::Search::GetAllIndexes::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_GET_ALL_INDEXES, options.parent_span, self, :search) do |obs_handler|
+          res = @backend.search_index_get_all(@bucket_name, @scope_name, options.timeout, obs_handler)
+          res[:indexes].map { |idx| SearchIndexManager.extract_search_index(idx) }
+        end
       end
 
       # Creates or updates the index
       #
       # @param [SearchIndex] index_definition the index definition
-      # @param [UpsertIndexOptions] options
+      # @param [Options::Search::UpsertIndex] options
       #
       # @return void
       #
       # @raise [ArgumentError] if name, type or source_type is empty
-      def upsert_index(index_definition, options = UpsertIndexOptions.new)
-        @backend.search_index_upsert(@bucket_name, @scope_name, index_definition.to_backend, options.timeout)
+      def upsert_index(index_definition, options = Options::Search::UpsertIndex::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_UPSERT_INDEX, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_upsert(@bucket_name, @scope_name, index_definition.to_backend, options.timeout, obs_handler)
+        end
       end
 
       # Drops the index
       #
       # @param [String] index_name name of the index
-      # @param [DropIndexOptions] options
+      # @param [Options::Search::DropIndex] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def drop_index(index_name, options = DropIndexOptions.new)
-        @backend.search_index_drop(@bucket_name, @scope_name, index_name, options.timeout)
+      def drop_index(index_name, options = Options::Search::DropIndex::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_DROP_INDEX, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_drop(@bucket_name, @scope_name, index_name, options.timeout, obs_handler)
+        end
       end
 
       # Retrieves the number of documents that have been indexed for an index
       #
       # @param [String] index_name name of the index
-      # @param [GetIndexedDocumentsCountOptions] options
+      # @param [Options::Search::GetIndexedDocumentsCount] options
       #
       # @return [Integer]
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def get_indexed_documents_count(index_name, options = GetIndexedDocumentsCountOptions.new)
-        res = @backend.search_index_get_documents_count(@bucket_name, @scope_name, index_name, options.timeout)
-        res[:count]
+      def get_indexed_documents_count(index_name, options = Options::Search::GetIndexedDocumentsCount::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_GET_INDEXED_DOCUMENTS_COUNT, options.parent_span, self,
+                                        :search) do |obs_handler|
+          res = @backend.search_index_get_documents_count(@bucket_name, @scope_name, index_name, options.timeout, obs_handler)
+          res[:count]
+        end
       end
 
       # Pauses updates and maintenance for the index
       #
       # @param [String] index_name name of the index
-      # @param [PauseIngestOptions] options
+      # @param [Options::Search::PauseIngest] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def pause_ingest(index_name, options = PauseIngestOptions.new)
-        @backend.search_index_pause_ingest(@bucket_name, @scope_name, index_name, options.timeout)
+      def pause_ingest(index_name, options = Options::Search::PauseIngest::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_PAUSE_INGEST, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_pause_ingest(@bucket_name, @scope_name, index_name, options.timeout, obs_handler)
+        end
       end
 
       # Resumes updates and maintenance for an index
       #
       # @param [String] index_name name of the index
-      # @param [ResumeIngestOptions] options
+      # @param [Options::Search::ResumeIngest] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def resume_ingest(index_name, options = ResumeIngestOptions.new)
-        @backend.search_index_resume_ingest(@bucket_name, @scope_name, index_name, options.timeout)
+      def resume_ingest(index_name, options = Options::Search::ResumeIngest::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_RESUME_INGEST, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_resume_ingest(@bucket_name, @scope_name, index_name, options.timeout, obs_handler)
+        end
       end
 
       # Allows querying against the index
       #
       # @param [String] index_name name of the index
-      # @param [AllowQueryingOptions] options
+      # @param [Options::Search::AllowQuerying] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def allow_querying(index_name, options = AllowQueryingOptions.new)
-        @backend.search_index_allow_querying(@bucket_name, @scope_name, index_name, options.timeout)
+      def allow_querying(index_name, options = Options::Search::AllowQuerying::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_ALLOW_QUERYING, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_allow_querying(@bucket_name, @scope_name, index_name, options.timeout, obs_handler)
+        end
       end
 
       # Disallows querying against the index
       #
       # @param [String] index_name name of the index
-      # @param [DisallowQueryingOptions] options
+      # @param [Options::Search::DisallowQuerying] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def disallow_querying(index_name, options = DisallowQueryingOptions.new)
-        @backend.search_index_disallow_querying(@bucket_name, @scope_name, index_name, options.timeout)
+      def disallow_querying(index_name, options = Options::Search::DisallowQuerying::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_DISALLOW_QUERYING, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_disallow_querying(@bucket_name, @scope_name, index_name, options.timeout, obs_handler)
+        end
       end
 
       # Freeze the assignment of index partitions to nodes
       #
       # @param [String] index_name name of the index
-      # @param [FreezePlanOptions] options
+      # @param [Options::Search::FreezePlan] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def freeze_plan(index_name, options = FreezePlanOptions.new)
-        @backend.search_index_freeze_plan(@bucket_name, @scope_name, index_name, options.timeout)
+      def freeze_plan(index_name, options = Options::Search::FreezePlan::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_FREEZE_PLAN, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_freeze_plan(@bucket_name, @scope_name, index_name, options.timeout, obs_handler)
+        end
       end
 
       # Unfreeze the assignment of index partitions to nodes
       #
       # @param [String] index_name name of the index
-      # @param [UnfreezePlanOptions] options
+      # @param [Options::Search::UnfreezePlan] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def unfreeze_plan(index_name, options = UnfreezePlanOptions.new)
-        @backend.search_index_unfreeze_plan(@bucket_name, @scope_name, index_name, options.timeout)
+      def unfreeze_plan(index_name, options = Options::Search::UnfreezePlan::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_UNFREEZE_PLAN, options.parent_span, self, :search) do |obs_handler|
+          @backend.search_index_unfreeze_plan(@bucket_name, @scope_name, index_name, options.timeout, obs_handler)
+        end
       end
 
       # Allows to see how a document is analyzed against a specific index
       #
       # @param [String] index_name name of the index
       # @param [Hash] document the document to be analyzed
+      # @param [Options::Search::AnalyzeDocument] options
       #
       # @return [Array<Hash>]
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def analyze_document(index_name, document, options = AnalyzeDocumentOptions.new)
-        res = @backend.search_index_analyze_document(@bucket_name, @scope_name, index_name, JSON.generate(document), options.timeout)
-        JSON.parse(res[:analysis])
+      def analyze_document(index_name, document, options = Options::Search::AnalyzeDocument::DEFAULT)
+        @observability.record_operation(Observability::OP_SM_ANALYZE_DOCUMENT, options.parent_span, self, :search) do |obs_handler|
+          res = @backend.search_index_analyze_document(
+            @bucket_name, @scope_name, index_name, JSON.generate(document), options.timeout, obs_handler
+          )
+          JSON.parse(res[:analysis])
+        end
       end
 
-      GetIndexOptions = SearchIndexManager::GetIndexOptions
-      GetAllIndexesOptions = SearchIndexManager::GetAllIndexesOptions
-      UpsertIndexOptions = SearchIndexManager::UpsertIndexOptions
-      DropIndexOptions = SearchIndexManager::DropIndexOptions
-      GetIndexedDocumentsCountOptions = SearchIndexManager::GetIndexedDocumentsCountOptions
-      PauseIngestOptions = SearchIndexManager::PauseIngestOptions
-      ResumeIngestOptions = SearchIndexManager::ResumeIngestOptions
-      AllowQueryingOptions = SearchIndexManager::AllowQueryingOptions
-      DisallowQueryingOptions = SearchIndexManager::DisallowQueryingOptions
-      FreezePlanOptions = SearchIndexManager::FreezePlanOptions
-      UnfreezePlanOptions = SearchIndexManager::UnfreezePlanOptions
-      AnalyzeDocumentOptions = SearchIndexManager::AnalyzeDocumentOptions
+      # @api private
+      # @deprecated use {Options::Search::GetIndex} instead
+      GetIndexOptions = Options::Search::GetIndex
+
+      # @api private
+      # @deprecated use {Options::Search::GetAllIndexes} instead
+      GetAllIndexesOptions = Options::Search::GetAllIndexes
+
+      # @api private
+      # @deprecated use {Options::Search::UpsertIndex} instead
+      UpsertIndexOptions = Options::Search::UpsertIndex
+
+      # @api private
+      # @deprecated use {Options::Search::DropIndex} instead
+      DropIndexOptions = Options::Search::DropIndex
+
+      # @api private
+      # @deprecated use {Options::Search::GetIndexedDocumentsCount} instead
+      GetIndexedDocumentsCountOptions = Options::Search::GetIndexedDocumentsCount
+
+      # @api private
+      # @deprecated use {Options::Search::PauseIngest} instead
+      PauseIngestOptions = Options::Search::PauseIngest
+
+      # @api private
+      # @deprecated use {Options::Search::ResumeIngest} instead
+      ResumeIngestOptions = Options::Search::ResumeIngest
+
+      # @api private
+      # @deprecated use {Options::Search::AllowQuerying} instead
+      AllowQueryingOptions = Options::Search::AllowQuerying
+
+      # @api private
+      # @deprecated use {Options::Search::DisallowQuerying} instead
+      DisallowQueryingOptions = Options::Search::DisallowQuerying
+
+      # @api private
+      # @deprecated use {Options::Search::FreezePlan} instead
+      FreezePlanOptions = Options::Search::FreezePlan
+
+      # @api private
+      # @deprecated use {Options::Search::UnfreezePlan} instead
+      UnfreezePlanOptions = Options::Search::UnfreezePlan
+
+      # @api private
+      # @deprecated use {Options::Search::AnalyzeDocument} instead
+      AnalyzeDocumentOptions = Options::Search::AnalyzeDocument
     end
   end
 end