couchbase 3.6.0-aarch64-linux → 3.8.0-aarch64-linux

data/lib/couchbase/management/bucket_manager.rb

@@ -190,8 +190,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
 
       # Creates new bucket
@@ -204,26 +208,32 @@ module Couchbase
       # @raise [ArgumentError]
       # @raise [Error::BucketExists]
       def create_bucket(settings, options = Options::Bucket::CreateBucket.new)
-        @backend.bucket_create(
-          {
-            name: settings.name,
-            flush_enabled: settings.flush_enabled,
-            ram_quota_mb: settings.ram_quota_mb,
-            num_replicas: settings.num_replicas,
-            replica_indexes: settings.replica_indexes,
-            bucket_type: settings.bucket_type,
-            eviction_policy: settings.eviction_policy,
-            max_expiry: settings.max_expiry,
-            compression_mode: settings.compression_mode,
-            minimum_durability_level: settings.minimum_durability_level,
-            conflict_resolution_type: settings.conflict_resolution_type,
-            storage_backend: settings.storage_backend,
-            history_retention_collection_default: settings.history_retention_collection_default,
-            history_retention_duration: settings.history_retention_duration,
-            history_retention_bytes: settings.history_retention_bytes,
-            num_vbuckets: settings.num_vbuckets,
-          }, options.to_backend
-        )
+        @observability.record_operation(Observability::OP_BM_CREATE_BUCKET, options.parent_span, self, :management) do |obs_handler|
+          obs_handler.add_bucket_name(settings.name)
+
+          @backend.bucket_create(
+            {
+              name: settings.name,
+              flush_enabled: settings.flush_enabled,
+              ram_quota_mb: settings.ram_quota_mb,
+              num_replicas: settings.num_replicas,
+              replica_indexes: settings.replica_indexes,
+              bucket_type: settings.bucket_type,
+              eviction_policy: settings.eviction_policy,
+              max_expiry: settings.max_expiry,
+              compression_mode: settings.compression_mode,
+              minimum_durability_level: settings.minimum_durability_level,
+              conflict_resolution_type: settings.conflict_resolution_type,
+              storage_backend: settings.storage_backend,
+              history_retention_collection_default: settings.history_retention_collection_default,
+              history_retention_duration: settings.history_retention_duration,
+              history_retention_bytes: settings.history_retention_bytes,
+              num_vbuckets: settings.num_vbuckets,
+            },
+            options.to_backend,
+            obs_handler,
+          )
+        end
       end
 
       # Updates the bucket settings
@@ -236,25 +246,31 @@ module Couchbase
       # @raise [ArgumentError]
       # @raise [Error::BucketNotFound]
       def update_bucket(settings, options = Options::Bucket::UpdateBucket.new)
-        @backend.bucket_update(
-          {
-            name: settings.name,
-            flush_enabled: settings.flush_enabled,
-            ram_quota_mb: settings.ram_quota_mb,
-            num_replicas: settings.num_replicas,
-            replica_indexes: settings.replica_indexes,
-            bucket_type: settings.bucket_type,
-            eviction_policy: settings.eviction_policy,
-            max_expiry: settings.max_expiry,
-            compression_mode: settings.compression_mode,
-            minimum_durability_level: settings.minimum_durability_level,
-            storage_backend: settings.storage_backend,
-            history_retention_collection_default: settings.history_retention_collection_default,
-            history_retention_bytes: settings.history_retention_bytes,
-            history_retention_duration: settings.history_retention_duration,
-            num_vbuckets: settings.num_vbuckets,
-          }, options.to_backend
-        )
+        @observability.record_operation(Observability::OP_BM_UPDATE_BUCKET, options.parent_span, self, :management) do |obs_handler|
+          obs_handler.add_bucket_name(settings.name)
+
+          @backend.bucket_update(
+            {
+              name: settings.name,
+              flush_enabled: settings.flush_enabled,
+              ram_quota_mb: settings.ram_quota_mb,
+              num_replicas: settings.num_replicas,
+              replica_indexes: settings.replica_indexes,
+              bucket_type: settings.bucket_type,
+              eviction_policy: settings.eviction_policy,
+              max_expiry: settings.max_expiry,
+              compression_mode: settings.compression_mode,
+              minimum_durability_level: settings.minimum_durability_level,
+              storage_backend: settings.storage_backend,
+              history_retention_collection_default: settings.history_retention_collection_default,
+              history_retention_bytes: settings.history_retention_bytes,
+              history_retention_duration: settings.history_retention_duration,
+              num_vbuckets: settings.num_vbuckets,
+            },
+            options.to_backend,
+            obs_handler,
+          )
+        end
       end
 
       # Removes a bucket
@@ -267,7 +283,11 @@ module Couchbase
       # @raise [ArgumentError]
       # @raise [Error::BucketNotFound]
       def drop_bucket(bucket_name, options = Options::Bucket::DropBucket.new)
-        @backend.bucket_drop(bucket_name, options.to_backend)
+        @observability.record_operation(Observability::OP_BM_DROP_BUCKET, options.parent_span, self, :management) do |obs_handler|
+          obs_handler.add_bucket_name(bucket_name)
+
+          @backend.bucket_drop(bucket_name, options.to_backend, obs_handler)
+        end
       end
 
       # Fetch settings of the bucket
@@ -280,7 +300,11 @@ module Couchbase
       # @raise [ArgumentError]
       # @raise [Error::BucketNotFound]
       def get_bucket(bucket_name, options = Options::Bucket::GetBucket.new)
-        extract_bucket_settings(@backend.bucket_get(bucket_name, options.to_backend))
+        @observability.record_operation(Observability::OP_BM_GET_BUCKET, options.parent_span, self, :management) do |obs_handler|
+          obs_handler.add_bucket_name(bucket_name)
+
+          extract_bucket_settings(@backend.bucket_get(bucket_name, options.to_backend, obs_handler))
+        end
       end
 
       # Get settings for all buckets
@@ -288,8 +312,10 @@ module Couchbase
       # @param [Options::Bucket::GetAllBuckets] options
       # @return [Array<BucketSettings>]
       def get_all_buckets(options = Options::Bucket::GetAllBuckets.new)
-        @backend.bucket_get_all(options.to_backend)
-                .map { |entry| extract_bucket_settings(entry) }
+        @observability.record_operation(Observability::OP_BM_GET_ALL_BUCKETS, options.parent_span, self, :management) do |obs_handler|
+          @backend.bucket_get_all(options.to_backend, obs_handler)
+                  .map { |entry| extract_bucket_settings(entry) }
+        end
       end
 
       # @param [String] bucket_name name of the bucket
@@ -301,7 +327,9 @@ module Couchbase
       # @raise [Error::BucketNotFound]
       # @raise [Error::BucketNotFlushable]
       def flush_bucket(bucket_name, options = Options::Bucket::FlushBucket.new)
-        @backend.bucket_flush(bucket_name, options.to_backend)
+        @observability.record_operation(Observability::OP_BM_FLUSH_BUCKET, options.parent_span, self, :management) do |obs_handler|
+          @backend.bucket_flush(bucket_name, options.to_backend, obs_handler)
+        end
       end
 
       # @api private

data/lib/couchbase/management/collection_manager.rb

@@ -198,9 +198,13 @@ module Couchbase
 
       # @param [Couchbase::Backend] backend
       # @param [String] bucket_name
-      def initialize(backend, bucket_name)
+      # @param [Observability::Wrapper] observability wrapper
+      #
+      # @api private
+      def initialize(backend, bucket_name, observability)
         @backend = backend
         @bucket_name = bucket_name
+        @observability = observability
       end
 
       # Get all scopes
@@ -209,16 +213,18 @@ module Couchbase
       #
       # @return [Array<ScopeSpec>]
       def get_all_scopes(options = Options::Collection::GetAllScopes.new)
-        res = @backend.scope_get_all(@bucket_name, options.to_backend)
-        res[:scopes].map do |s|
-          ScopeSpec.new do |scope|
-            scope.name = s[:name]
-            scope.collections = s[:collections].map do |c|
-              CollectionSpec.new do |collection|
-                collection.name = c[:name]
-                collection.scope_name = s[:name]
-                collection.max_expiry = c[:max_expiry]
-                collection.history = c[:history]
+        @observability.record_operation(Observability::OP_CM_GET_ALL_SCOPES, options.parent_span, self, :management) do |obs_handler|
+          res = @backend.scope_get_all(@bucket_name, options.to_backend, obs_handler)
+          res[:scopes].map do |s|
+            ScopeSpec.new do |scope|
+              scope.name = s[:name]
+              scope.collections = s[:collections].map do |c|
+                CollectionSpec.new do |collection|
+                  collection.name = c[:name]
+                  collection.scope_name = s[:name]
+                  collection.max_expiry = c[:max_expiry]
+                  collection.history = c[:history]
+                end
               end
             end
           end
@@ -236,8 +242,12 @@ module Couchbase
       #
       # @raise [Error::ScopeNotFound]
       def get_scope(scope_name, options = GetScopeOptions.new)
-        get_all_scopes(Options::Collection::GetAllScopes(timeout: options.timeout))
-          .find { |scope| scope.name == scope_name } or raise Error::ScopeNotFound, "unable to find scope #{scope_name}"
+        @observability.record_operation(Observability::OP_CM_GET_SCOPE, options.parent_span, self, :management) do |obs_handler|
+          obs_handler.add_scope_name(scope_name)
+
+          get_all_scopes(Options::Collection::GetAllScopes(timeout: options.timeout, parent_span: obs_handler.op_span))
+            .find { |scope| scope.name == scope_name } or raise Error::ScopeNotFound, "unable to find scope #{scope_name}"
+        end
       end
 
       deprecate :get_scope, :get_all_scopes, 2021, 6
@@ -251,7 +261,11 @@ module Couchbase
       #
       # @raise [ArgumentError]
       def create_scope(scope_name, options = Options::Collection::CreateScope.new)
-        @backend.scope_create(@bucket_name, scope_name, options.to_backend)
+        @observability.record_operation(Observability::OP_CM_CREATE_SCOPE, options.parent_span, self, :management) do |obs_handler|
+          obs_handler.add_scope_name(scope_name)
+
+          @backend.scope_create(@bucket_name, scope_name, options.to_backend, obs_handler)
+        end
       end
 
       # Removes a scope
@@ -263,7 +277,11 @@ module Couchbase
       #
       # @raise [Error::ScopeNotFound]
       def drop_scope(scope_name, options = Options::Collection::DropScope.new)
-        @backend.scope_drop(@bucket_name, scope_name, options.to_backend)
+        @observability.record_operation(Observability::OP_CM_DROP_SCOPE, options.parent_span, self, :management) do |obs_handler|
+          obs_handler.add_scope_name(scope_name)
+
+          @backend.scope_drop(@bucket_name, scope_name, options.to_backend, obs_handler)
+        end
       end
 
       # Creates a new collection
@@ -286,21 +304,31 @@ module Couchbase
       # @raise [Error::CollectionExists]
       # @raise [Error::ScopeNotFound]
       def create_collection(*args)
-        if args[0].is_a?(CollectionSpec)
-          collection = args[0]
-          options = args[1] || Options::Collection::CreateCollection::DEFAULT
-          settings = CreateCollectionSettings.new(max_expiry: collection.max_expiry, history: collection.history)
-
-          warn "Calling create_collection with a CollectionSpec object has been deprecated, supply scope name, " \
-               "collection name and optionally a CreateCollectionSettings instance"
-
-          @backend.collection_create(@bucket_name, collection.scope_name, collection.name, settings.to_backend, options.to_backend)
-        else
-          scope_name = args[0]
-          collection_name = args[1]
-          settings = args[2] || CreateCollectionSettings::DEFAULT
-          options = args[3] || Options::Collection::CreateCollection::DEFAULT
-          @backend.collection_create(@bucket_name, scope_name, collection_name, settings.to_backend, options.to_backend)
+        scope_name, collection_name, settings, options =
+          if args[0].is_a?(CollectionSpec)
+            warn "Calling create_collection with a CollectionSpec object has been deprecated, supply scope name, " \
+                 "collection name and optionally a CreateCollectionSettings instance"
+            collection = args[0]
+            [
+              collection.scope_name,
+              collection.name,
+              CreateCollectionSettings.new(max_expiry: collection.max_expiry, history: collection.history),
+              args[1] || Options::Collection::CreateCollection::DEFAULT,
+            ]
+          else
+            [
+              args[0],
+              args[1],
+              args[2] || CreateCollectionSettings::DEFAULT,
+              args[3] || Options::Collection::CreateCollection::DEFAULT,
+            ]
+          end
+
+        @observability.record_operation(Observability::OP_CM_CREATE_COLLECTION, options.parent_span, self, :management) do |obs_handler|
+          obs_handler.add_scope_name(scope_name)
+          obs_handler.add_collection_name(collection_name)
+
+          @backend.collection_create(@bucket_name, scope_name, collection_name, settings.to_backend, options.to_backend, obs_handler)
         end
       end
 
@@ -315,7 +343,12 @@ module Couchbase
       # @raise [Error::ScopeNotFound]
       def update_collection(scope_name, collection_name, settings = UpdateCollectionSettings::DEFAULT,
                             options = Options::Collection::UpdateCollection::DEFAULT)
-        @backend.collection_update(@bucket_name, scope_name, collection_name, settings.to_backend, options.to_backend)
+        @observability.record_operation(Observability::OP_CM_UPDATE_COLLECTION, options.parent_span, self, :management) do |obs_handler|
+          obs_handler.add_scope_name(scope_name)
+          obs_handler.add_collection_name(collection_name)
+
+          @backend.collection_update(@bucket_name, scope_name, collection_name, settings.to_backend, options.to_backend, obs_handler)
+        end
       end
 
       # Removes a collection
@@ -336,18 +369,28 @@ module Couchbase
       # @raise [Error::CollectionNotFound]
       # @raise [Error::ScopeNotFound]
       def drop_collection(*args)
-        if args[0].is_a?(CollectionSpec)
-          collection = args[0]
-          options = args[1] || Options::Collection::CreateCollection::DEFAULT
-
-          warn "Calling drop_collection with a CollectionSpec object has been deprecated, supply scope name and collection name"
-
-          @backend.collection_drop(@bucket_name, collection.scope_name, collection.name, options.to_backend)
-        else
-          scope_name = args[0]
-          collection_name = args[1]
-          options = args[2] || Options::Collection::CreateCollection::DEFAULT
-          @backend.collection_drop(@bucket_name, scope_name, collection_name, options.to_backend)
+        scope_name, collection_name, options =
+          if args[0].is_a?(CollectionSpec)
+            warn "Calling drop_collection with a CollectionSpec object has been deprecated, supply scope name and collection name"
+            collection = args[0]
+            [
+              collection.scope_name,
+              collection.name,
+              args[1] || Options::Collection::CreateCollection::DEFAULT,
+            ]
+          else
+            [
+              args[0],
+              args[1],
+              args[2] || Options::Collection::CreateCollection::DEFAULT,
+            ]
+          end
+
+        @observability.record_operation(Observability::OP_CM_DROP_COLLECTION, options.parent_span, self, :management) do |obs_handler|
+          obs_handler.add_scope_name(scope_name)
+          obs_handler.add_collection_name(collection_name)
+
+          @backend.collection_drop(@bucket_name, scope_name, collection_name, options.to_backend, obs_handler)
         end
       end
 

data/lib/couchbase/management/collection_query_index_manager.rb

@@ -27,11 +27,15 @@ module Couchbase
       # @param [String] bucket_name name of the bucket
       # @param [String] scope_name name of the scope
       # @param [String] collection_name name of the collection
-      def initialize(backend, bucket_name, scope_name, collection_name)
+      # @param [Observability::Wrapper] observability wrapper
+      #
+      # @api private
+      def initialize(backend, bucket_name, scope_name, collection_name, observability)
         @backend = backend
         @bucket_name = bucket_name
         @scope_name = scope_name
         @collection_name = collection_name
+        @observability = observability
       end
 
       # Fetches all indexes from the server
@@ -52,19 +56,21 @@ module Couchbase
                 "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
-        res = @backend.collection_query_index_get_all(@bucket_name, @scope_name, @collection_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|
+          res = @backend.collection_query_index_get_all(@bucket_name, @scope_name, @collection_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
@@ -90,7 +96,10 @@ module Couchbase
                 "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
-        @backend.collection_query_index_create(@bucket_name, @scope_name, @collection_name, index_name, fields, options.to_backend)
+        @observability.record_operation(Observability::OP_QM_CREATE_INDEX, options.parent_span, self, :query) do |obs_handler|
+          @backend.collection_query_index_create(@bucket_name, @scope_name, @collection_name, index_name, fields, options.to_backend,
+                                                 obs_handler)
+        end
       end
 
       # Creates new primary index
@@ -112,7 +121,9 @@ module Couchbase
                 "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
-        @backend.collection_query_index_create_primary(@bucket_name, @scope_name, @collection_name, options.to_backend)
+        @observability.record_operation(Observability::OP_QM_CREATE_PRIMARY_INDEX, options.parent_span, self, :query) do |obs_handler|
+          @backend.collection_query_index_create_primary(@bucket_name, @scope_name, @collection_name, options.to_backend, obs_handler)
+        end
       end
 
       # Drops the index
@@ -135,7 +146,9 @@ module Couchbase
                 "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
-        @backend.collection_query_index_drop(@bucket_name, @scope_name, @collection_name, index_name, options.to_backend)
+        @observability.record_operation(Observability::OP_QM_DROP_INDEX, options.parent_span, self, :query) do |obs_handler|
+          @backend.collection_query_index_drop(@bucket_name, @scope_name, @collection_name, index_name, options.to_backend, obs_handler)
+        end
       end
 
       # Drops the primary index
@@ -157,7 +170,9 @@ module Couchbase
                 "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
-        @backend.collection_query_index_drop_primary(@bucket_name, @scope_name, @collection_name, options.to_backend)
+        @observability.record_operation(Observability::OP_QM_DROP_PRIMARY_INDEX, options.parent_span, self, :query) do |obs_handler|
+          @backend.collection_query_index_drop_primary(@bucket_name, @scope_name, @collection_name, options.to_backend, obs_handler)
+        end
       end
 
       # Build all indexes which are currently in deferred state
@@ -178,7 +193,9 @@ module Couchbase
                 "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
-        @backend.collection_query_index_build_deferred(@bucket_name, @scope_name, @collection_name, options.to_backend)
+        @observability.record_operation(Observability::OP_QM_BUILD_DEFERRED_INDEXES, options.parent_span, self, :query) do |obs_handler|
+          @backend.collection_query_index_build_deferred(@bucket_name, @scope_name, @collection_name, options.to_backend, obs_handler)
+        end
       end
 
       # Polls indexes until they are online
@@ -200,24 +217,30 @@ module Couchbase
                 "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
-        index_names.append("#primary") if options.watch_primary
+        @observability.record_operation(Observability::OP_QM_WATCH_INDEXES, options.parent_span, self, :query) do |obs_handler|
+          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(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?
+          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,
+              parent_span: obs_handler.op_span,
+            )
+            indexes = get_all_indexes(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
+            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
+            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
     end
   end