couchbase 3.0.0.alpha.3-universal-darwin-19 → 3.0.1-universal-darwin-19

data/lib/couchbase.rb

@@ -15,4 +15,3 @@
 require "couchbase/version"
 require "couchbase/libcouchbase"
 require "couchbase/cluster"
-

data/lib/couchbase/analytics_options.rb

@@ -0,0 +1,177 @@
+#    Copyright 2020 Couchbase, Inc.
+#
+#  Licensed 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 'couchbase/json_transcoder'
+
+module Couchbase
+  class Cluster
+    class AnalyticsOptions
+      # @return [Integer] Timeout in milliseconds
+      attr_accessor :timeout
+
+      # @return [String] Provides a custom client context ID for this query
+      attr_accessor :client_context_id
+
+      # @return [:not_bounded, :request_plus] specifies level of consistency for the query
+      attr_accessor :scan_consistency
+
+      # @return [Boolean] Allows explicitly marking a query as being readonly and not mutating any documents on the server side.
+      attr_accessor :readonly
+
+      # @return [Boolean] Allows to give certain requests higher priority than others
+      attr_accessor :priority
+
+      # @return [JsonTranscoder] transcoder to use on rows
+      attr_accessor :transcoder
+
+      # @api private
+      # @return [Hash<String => #to_json>]
+      attr_reader :raw_parameters
+
+      # @yieldparam [AnalyticsOptions] self
+      def initialize
+        @transcoder = JsonTranscoder.new
+        @raw_parameters = {}
+        @positional_parameters = nil
+        @named_parameters = nil
+        @scan_consistency = nil
+        yield self if block_given?
+      end
+
+      # Sets positional parameters for the query
+      #
+      # @param [Array] positional the list of parameters that have to be substituted in the statement
+      def positional_parameters(positional)
+        @positional_parameters = positional
+        @named_parameters = nil
+      end
+
+      # @api private
+      # @return [Array<String>, nil]
+      def export_positional_parameters
+        @positional_parameters&.map { |p| JSON.dump(p) }
+      end
+
+      # Sets named parameters for the query
+      #
+      # @param [Hash] named the key/value map of the parameters to substitute in the statement
+      def named_parameters(named)
+        @named_parameters = named
+        @positional_parameters = nil
+      end
+
+      # Allows providing custom JSON key/value pairs for advanced usage
+      #
+      # @param [String] key the parameter name (key of the JSON property)
+      # @param [Object] value the parameter value (value of the JSON property)
+      def raw(key, value)
+        @raw_parameters[key] = JSON.generate(value)
+      end
+
+      # @api private
+      # @return [Hash<String => String>, nil]
+      def export_named_parameters
+        @named_parameters&.each_with_object({}) { |(n, v), o| o[n.to_s] = JSON.dump(v) }
+      end
+    end
+
+    class AnalyticsWarning
+      # @return [Integer]
+      attr_accessor :code
+
+      # @return [String]
+      attr_accessor :message
+
+      # @param [Integer] code
+      # @param [String] message
+      def initialize(code, message)
+        @code = code
+        @message = message
+      end
+    end
+
+    class AnalyticsMetrics
+      # @return [Integer] duration in milliseconds
+      attr_accessor :elapsed_time
+
+      # @return [Integer] duration in milliseconds
+      attr_accessor :execution_time
+
+      # @return [Integer]
+      attr_accessor :result_count
+
+      # @return [Integer]
+      attr_accessor :result_size
+
+      # @return [Integer]
+      attr_accessor :error_count
+
+      # @return [Integer]
+      attr_accessor :processed_objects
+
+      # @return [Integer]
+      attr_accessor :warning_count
+
+      # @yieldparam [AnalyticsMetrics] self
+      def initialize
+        yield self if block_given?
+      end
+    end
+
+    class AnalyticsMetaData
+      # @return [String]
+      attr_accessor :request_id
+
+      # @return [String]
+      attr_accessor :client_context_id
+
+      # @return [:running, :success, :errors, :completed, :stopped, :timeout, :closed, :fatal, :aborted, :unknown]
+      attr_accessor :status
+
+      # @return [Hash] returns the signature as returned by the query engine which is then decoded as JSON object
+      attr_accessor :signature
+
+      # @return [Array<AnalyticsWarning>]
+      attr_accessor :warnings
+
+      # @return [AnalyticsMetrics]
+      attr_accessor :metrics
+
+      # @yieldparam [AnalyticsMetaData] self
+      def initialize
+        yield self if block_given?
+      end
+    end
+
+    class AnalyticsResult
+      # @return [AnalyticsMetaData]
+      attr_accessor :meta_data
+
+      attr_accessor :transcoder
+
+      # Returns all rows converted using a transcoder
+      #
+      # @return [Array]
+      def rows(transcoder = self.transcoder)
+        @rows.lazy.map { |row| transcoder.decode(row, 0) }
+      end
+
+      # @yieldparam [AnalyticsResult] self
+      def initialize
+        @transcoder = JsonTranscoder.new
+        yield self if block_given?
+      end
+    end
+  end
+end

data/lib/couchbase/authenticator.rb

@@ -13,6 +13,7 @@
 #  limitations under the License.
 
 module Couchbase
+  # Authenticator for username/password credentials
   class PasswordAuthenticator
     attr_accessor :username
     attr_accessor :password
@@ -22,4 +23,17 @@ module Couchbase
       @password = password
     end
   end
+
+  # Authenticator for TLS client certificate
+  #
+  # @see https://docs.couchbase.com/server/current/manage/manage-security/configure-client-certificates.html
+  class CertificateAuthenticator
+    attr_accessor :certificate_path
+    attr_accessor :key_path
+
+    def initialize(certificate_path, key_path)
+      @certificate_path = certificate_path
+      @key_path = key_path
+    end
+  end
 end

data/lib/couchbase/binary_collection.rb

@@ -16,7 +16,7 @@ require "couchbase/binary_collection_options"
 
 module Couchbase
   class BinaryCollection
-    alias_method :inspect, :to_s
+    alias inspect to_s
 
     # @param [Couchbase::Collection] collection parent collection
     def initialize(collection)
@@ -52,10 +52,10 @@ module Couchbase
       resp = @backend.document_increment(@collection.bucket_name, "#{@collection.scope_name}.#{@collection.name}", id,
                                          options.timeout,
                                          {
-                                             delta: options.delta,
-                                             initial_value: options.initial,
-                                             expiration: options.expiration,
-                                             durability_level: options.durability_level,
+                                           delta: options.delta,
+                                           initial_value: options.initial,
+                                           expiry: options.expiry,
+                                           durability_level: options.durability_level,
                                          })
       CounterResult.new do |res|
         res.cas = resp[:cas]
@@ -74,10 +74,10 @@ module Couchbase
       resp = @backend.document_decrement(@collection.bucket_name, "#{@collection.scope_name}.#{@collection.name}", id,
                                          options.timeout,
                                          {
-                                             delta: options.delta,
-                                             initial_value: options.initial,
-                                             expiration: options.expiration,
-                                             durability_level: options.durability_level,
+                                           delta: options.delta,
+                                           initial_value: options.initial,
+                                           expiry: options.expiry,
+                                           durability_level: options.durability_level,
                                          })
       CounterResult.new do |res|
         res.cas = resp[:cas]

data/lib/couchbase/binary_collection_options.rb

@@ -22,6 +22,7 @@ module Couchbase
 
       # @yieldparam [AppendOptions] self
       def initialize
+        super
         yield self if block_given?
       end
     end
@@ -32,6 +33,7 @@ module Couchbase
 
       # @yieldparam [PrependOptions] self
       def initialize
+        super
         yield self if block_given?
       end
     end
@@ -44,21 +46,21 @@ module Couchbase
       attr_accessor :initial
 
       # @return [Integer] if set, holds the expiration for the operation
-      attr_accessor :expiration
+      attr_accessor :expiry
 
       # @return [:none, :majority, :majority_and_persist_to_active, :persist_to_majority] level of durability
       attr_accessor :durability_level
 
       # @yieldparam [IncrementOptions] self
       def initialize
+        super
         @delta = 1
         yield self if block_given?
       end
 
       def delta=(value)
-        if delta < 0
-          raise ArgumentError, "the delta cannot be less than 0"
-        end
+        raise ArgumentError, "the delta cannot be less than 0" if delta.negative?
+
         @delta = value
       end
     end
@@ -71,21 +73,21 @@ module Couchbase
       attr_accessor :initial
 
       # @return [Integer] if set, holds the expiration for the operation
-      attr_accessor :expiration
+      attr_accessor :expiry
 
       # @return [:none, :majority, :majority_and_persist_to_active, :persist_to_majority] level of durability
       attr_accessor :durability_level
 
       # @yieldparam [DecrementOptions] self
       def initialize
+        super
         @delta = 1
         yield self if block_given?
       end
 
       def delta=(value)
-        if delta < 0
-          raise ArgumentError, "the delta cannot be less than 0"
-        end
+        raise ArgumentError, "the delta cannot be less than 0" if delta.negative?
+
         @delta = value
       end
     end

data/lib/couchbase/bucket.rb

@@ -14,14 +14,19 @@
 
 require "couchbase/scope"
 require "couchbase/management/collection_manager"
+require "couchbase/management/view_index_manager"
+require "couchbase/view_options"
 
 module Couchbase
   class Bucket
-    alias_method :inspect, :to_s
+    # @return [String] name of the bucket
+    attr_reader :name
+
+    alias inspect to_s
 
     # @param [Couchbase::Backend] backend
     def initialize(backend, name)
-      backend.open_bucket(name)
+      backend.open_bucket(name, true)
       @backend = backend
       @name = name
     end
@@ -55,7 +60,49 @@ module Couchbase
     #
     # @return [Collection]
     def default_collection
-      default_scope.default_collection
+      Collection.new(@backend, @name, :_default, :_default)
+    end
+
+    # Performs query to view index.
+    #
+    # @param [String] design_document_name name of the design document
+    # @param [String] view_name name of the view to query
+    # @param [ViewOptions] options
+    #
+    # @return [ViewResult]
+    def view_query(design_document_name, view_name, options = ViewOptions.new)
+      resp = @backend.document_view(@name, design_document_name, view_name, options.namespace, {
+        timeout: options.timeout,
+        scan_consistency: options.scan_consistency,
+        skip: options.skip,
+        limit: options.limit,
+        start_key: (JSON.generate(options.start_key) unless options.start_key.nil?),
+        end_key: (JSON.generate(options.end_key) unless options.end_key.nil?),
+        start_key_doc_id: options.start_key_doc_id,
+        end_key_doc_id: options.end_key_doc_id,
+        inclusive_end: options.inclusive_end,
+        group: options.group,
+        group_level: options.group_level,
+        key: (JSON.generate(options.key) unless options.key.nil?),
+        keys: options.keys&.map { |key| JSON.generate(key) },
+        order: options.order,
+        reduce: options.reduce,
+        on_error: options.on_error,
+        debug: options.debug,
+      })
+      ViewResult.new do |res|
+        res.meta_data = ViewMetaData.new do |meta|
+          meta.total_rows = resp[:meta][:total_rows]
+          meta.debug_info = resp[:meta][:debug_info]
+        end
+        res.rows = resp[:rows].map do |entry|
+          ViewRow.new do |row|
+            row.id = entry[:id] if entry.key?(:id)
+            row.key = JSON.parse(entry[:key])
+            row.value = JSON.parse(entry[:value])
+          end
+        end
+      end
     end
 
     # @return [Management::CollectionManager]
@@ -63,6 +110,11 @@ module Couchbase
       Management::CollectionManager.new(@backend, @name)
     end
 
+    # @return [Management::ViewIndexManager]
+    def view_indexes
+      Management::ViewIndexManager.new(@backend, @name)
+    end
+
     # Performs application-level ping requests against services in the couchbase cluster
     #
     # @return [PingResult]

data/lib/couchbase/cluster.rb

@@ -22,21 +22,36 @@ require "couchbase/management/analytics_index_manager"
 require "couchbase/management/search_index_manager"
 
 require "couchbase/search_options"
+require "couchbase/query_options"
+require "couchbase/analytics_options"
 
 module Couchbase
   class Cluster
-    alias_method :inspect, :to_s
+    alias inspect to_s
 
     # Connect to the Couchbase cluster
     #
-    # @param [String] connection_string connection string used to locate the Couchbase Cluster
-    # @param [ClusterOptions] options custom options when creating the cluster connection
+    # @overload connect(connection_string, options)
+    #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+    #   @param [ClusterOptions] options custom options when creating the cluster connection
+    #
+    # @overload connect(connection_string, username, password, options)
+    #   Shortcut for {PasswordAuthenticator}
+    #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+    #   @param [String] username name of the user
+    #   @param [String] password password of the user
+    #   @param [ClusterOptions, nil] options custom options when creating the cluster connection
     #
     # @return [Cluster]
-    def self.connect(connection_string, options)
-      Cluster.new(connection_string, options)
+    def self.connect(connection_string, *options)
+      Cluster.new(connection_string, *options)
     end
 
+    # Returns an instance of the {Bucket}
+    #
+    # @param [String] name name of the bucket
+    #
+    # @return [Bucket]
     def bucket(name)
       Bucket.new(@backend, name)
     end
@@ -49,29 +64,24 @@ module Couchbase
     # @return [QueryResult]
     def query(statement, options = QueryOptions.new)
       resp = @backend.document_query(statement, {
-          timeout: options.timeout,
-          adhoc: options.adhoc,
-          client_context_id: options.client_context_id,
-          max_parallelism: options.max_parallelism,
-          readonly: options.readonly,
-          scan_wait: options.scan_wait,
-          scan_cap: options.scan_cap,
-          pipeline_batch: options.pipeline_batch,
-          pipeline_cap: options.pipeline_cap,
-          metrics: options.metrics,
-          profile: options.profile,
-          positional_parameters: options.instance_variable_get("@positional_parameters")&.map { |p| JSON.dump(p) },
-          named_parameters: options.instance_variable_get("@named_parameters")&.each_with_object({}) { |(n, v), o| o[n.to_s] = JSON.dump(v) },
-          raw_parameters: options.instance_variable_get("@raw_parameters"),
-          scan_consistency: options.instance_variable_get("@scan_consistency"),
-          mutation_state: options.instance_variable_get("@mutation_state")&.tokens&.map { |t|
-            {
-                bucket_name: t.bucket_name,
-                partition_id: t.partition_id,
-                partition_uuid: t.partition_uuid,
-                sequence_number: t.sequence_number,
-            }
-          },
+        timeout: options.timeout,
+        adhoc: options.adhoc,
+        client_context_id: options.client_context_id,
+        max_parallelism: options.max_parallelism,
+        readonly: options.readonly,
+        flex_index: options.flex_index,
+        scan_wait: options.scan_wait,
+        scan_cap: options.scan_cap,
+        pipeline_batch: options.pipeline_batch,
+        pipeline_cap: options.pipeline_cap,
+        metrics: options.metrics,
+        profile: options.profile,
+        positional_parameters: options.export_positional_parameters,
+        named_parameters: options.export_named_parameters,
+        scope_qualifier: options.scope_qualifier,
+        raw_parameters: options.raw_parameters,
+        scan_consistency: options.scan_consistency,
+        mutation_state: options.mutation_state&.to_a,
       })
 
       QueryResult.new do |res|
@@ -87,6 +97,7 @@ module Couchbase
               metrics.execution_time = resp[:meta][:metrics][:execution_time]
               metrics.sort_count = resp[:meta][:metrics][:sort_count]
               metrics.result_count = resp[:meta][:metrics][:result_count]
+              metrics.result_size = resp[:meta][:metrics][:result_size]
               metrics.mutation_count = resp[:meta][:metrics][:mutation_count]
               metrics.error_count = resp[:meta][:metrics][:error_count]
               metrics.warning_count = resp[:meta][:metrics][:warning_count]
@@ -104,7 +115,42 @@ module Couchbase
     # @param [AnalyticsOptions] options the custom options for this query
     #
     # @return [AnalyticsResult]
-    def analytics_query(statement, options = AnalyticsOptions.new) end
+    def analytics_query(statement, options = AnalyticsOptions.new)
+      resp = @backend.document_analytics(statement, {
+        timeout: options.timeout,
+        client_context_id: options.client_context_id,
+        scan_consistency: options.scan_consistency,
+        readonly: options.readonly,
+        priority: options.priority,
+        positional_parameters: options.export_positional_parameters,
+        named_parameters: options.export_named_parameters,
+        raw_parameters: options.raw_parameters,
+      })
+
+      AnalyticsResult.new do |res|
+        res.transcoder = options.transcoder
+        res.meta_data = AnalyticsMetaData.new do |meta|
+          meta.status = resp[:meta][:status]
+          meta.request_id = resp[:meta][:request_id]
+          meta.client_context_id = resp[:meta][:client_context_id]
+          meta.signature = JSON.parse(resp[:meta][:signature]) if resp[:meta][:signature]
+          meta.profile = JSON.parse(resp[:meta][:profile]) if resp[:meta][:profile]
+          meta.metrics = AnalyticsMetrics.new do |metrics|
+            if resp[:meta][:metrics]
+              metrics.elapsed_time = resp[:meta][:metrics][:elapsed_time]
+              metrics.execution_time = resp[:meta][:metrics][:execution_time]
+              metrics.result_count = resp[:meta][:metrics][:result_count]
+              metrics.result_size = resp[:meta][:metrics][:result_size]
+              metrics.error_count = resp[:meta][:metrics][:error_count]
+              metrics.warning_count = resp[:meta][:metrics][:warning_count]
+              metrics.processed_objects = resp[:meta][:metrics][:processed_objects]
+            end
+          end
+          res[:warnings] = resp[:warnings].map { |warn| QueryWarning.new(warn[:code], warn[:message]) } if resp[:warnings]
+        end
+        res.instance_variable_set("@rows", resp[:rows])
+      end
+    end
 
     # Performs a Full Text Search (FTS) query
     #
@@ -115,24 +161,18 @@ module Couchbase
     # @return [SearchResult]
     def search_query(index_name, query, options = SearchOptions.new)
       resp = @backend.document_search(index_name, JSON.generate(query), {
-          timeout: options.timeout,
-          limit: options.limit,
-          skip: options.skip,
-          explain: options.explain,
-          highlight_style: options.highlight_style,
-          highlight_fields: options.highlight_fields,
-          fields: options.fields,
-          sort: options.sort&.map { |v| JSON.generate(v) },
-          facets: options.facets&.map { |(k, v)| [k, JSON.generate(v)] },
-          scan_consistency: options.instance_variable_get("@scan_consistency"),
-          mutation_state: options.instance_variable_get("@mutation_state")&.tokens&.map { |t|
-            {
-                bucket_name: t.bucket_name,
-                partition_id: t.partition_id,
-                partition_uuid: t.partition_uuid,
-                sequence_number: t.sequence_number,
-            }
-          },
+        timeout: options.timeout,
+        limit: options.limit,
+        skip: options.skip,
+        explain: options.explain,
+        disable_scoring: options.disable_scoring,
+        highlight_style: options.highlight_style,
+        highlight_fields: options.highlight_fields,
+        fields: options.fields,
+        sort: options.sort&.map { |v| JSON.generate(v) },
+        facets: options.facets&.map { |(k, v)| [k, JSON.generate(v)] },
+        scan_consistency: options.scan_consistency,
+        mutation_state: options.mutation_state&.to_a,
       })
 
       SearchResult.new do |res|
@@ -142,6 +182,7 @@ module Couchbase
           meta.metrics.success_partition_count = resp[:meta_data][:metrics][:success_partition_count]
           meta.metrics.took = resp[:meta_data][:metrics][:took]
           meta.metrics.total_rows = resp[:meta_data][:metrics][:total_rows]
+          meta.errors = resp[:meta_data][:errors]
         end
         res.rows = resp[:rows].map do |r|
           SearchRow.new do |row|
@@ -151,50 +192,67 @@ module Couchbase
             row.score = r[:score]
             row.fragments = r[:fragments]
             row.locations = SearchRowLocations.new(
-                r[:locations].map do |loc|
-                  SearchRowLocation.new do |location|
-                    location.field = loc[:field]
-                    location.term = loc[:term]
-                    location.position = loc[:position]
-                    location.start_offset = loc[:start_offset]
-                    location.end_offset = loc[:end_offset]
-                    location.array_positions = loc[:array_positions]
-                  end
+              r[:locations].map do |loc|
+                SearchRowLocation.new do |location|
+                  location.field = loc[:field]
+                  location.term = loc[:term]
+                  location.position = loc[:position]
+                  location.start_offset = loc[:start_offset]
+                  location.end_offset = loc[:end_offset]
+                  location.array_positions = loc[:array_positions]
                 end
+              end
             )
             row.instance_variable_set("@fields", r[:fields])
             row.explanation = JSON.parse(r[:explanation]) if r[:explanation]
           end
         end
-        res.facets = resp[:facets]&.each_with_object({}) do |(k, v), o|
-          facet = case options.facets[k]
-                  when SearchFacet::SearchFacetTerm
-                    SearchFacetResult::TermFacetResult.new do |f|
-                      f.terms = v[:terms]&.map do |t|
-                        SearchFacetResult::TermFacetResult::TermFacet.new(t[:term], t[:count])
-                      end || []
+        if resp[:facets]
+          res.facets = resp[:facets].each_with_object({}) do |(k, v), o|
+            facet = case options.facets[k]
+                    when SearchFacet::SearchFacetTerm
+                      SearchFacetResult::TermFacetResult.new do |f|
+                        f.terms =
+                          if v[:terms]
+                            v[:terms].map do |t|
+                              SearchFacetResult::TermFacetResult::TermFacet.new(t[:term], t[:count])
+                            end
+                          else
+                            []
+                          end
+                      end
+                    when SearchFacet::SearchFacetDateRange
+                      SearchFacetResult::DateRangeFacetResult.new do |f|
+                        f.date_ranges =
+                          if v[:date_ranges]
+                            v[:date_ranges].map do |r|
+                              SearchFacetResult::DateRangeFacetResult::DateRangeFacet.new(r[:name], r[:count], r[:start_time], r[:end_time])
+                            end
+                          else
+                            []
+                          end
+                      end
+                    when SearchFacet::SearchFacetNumericRange
+                      SearchFacetResult::NumericRangeFacetResult.new do |f|
+                        f.numeric_ranges =
+                          if v[:numeric_ranges]
+                            v[:numeric_ranges].map do |r|
+                              SearchFacetResult::NumericRangeFacetResult::NumericRangeFacet.new(r[:name], r[:count], r[:min], r[:max])
+                            end
+                          else
+                            []
+                          end
+                      end
+                    else
+                      next # ignore unknown facet result
                     end
-                  when SearchFacet::SearchFacetDateRange
-                    SearchFacetResult::DateRangeFacetResult.new do |f|
-                      f.date_ranges = v[:date_ranges]&.map do |r|
-                        SearchFacetResult::DateRangeFacetResult::DateRangeFacet.new(r[:name], r[:count], r[:start_time], r[:end_time])
-                      end || []
-                    end
-                  when SearchFacet::SearchFacetNumericRange
-                    SearchFacetResult::NumericRangeFacetResult.new do |f|
-                      f.numeric_ranges = v[:numeric_ranges]&.map do |r|
-                        SearchFacetResult::NumericRangeFacetResult::NumericRangeFacet.new(r[:name], r[:count], r[:min], r[:max])
-                      end || []
-                    end
-                  else
-                    next # ignore unknown facet result
-                  end
-          facet.name = v[:name]
-          facet.field = v[:field]
-          facet.total = v[:total]
-          facet.missing = v[:missing]
-          facet.other = v[:other]
-          o[k] = facet
+            facet.name = v[:name]
+            facet.field = v[:field]
+            facet.total = v[:total]
+            facet.missing = v[:missing]
+            facet.other = v[:other]
+            o[k] = facet
+          end
         end
       end
     end
@@ -224,15 +282,43 @@ module Couchbase
       Management::SearchIndexManager.new(@backend)
     end
 
+    # Closes all connections to services and free allocated resources
+    #
+    # @return [void]
     def disconnect
       @backend.close
     end
 
-    def diagnostics(options = DiagnosticsOptions.new) end
+    # Creates diagnostic report that can be used to determine the health of the network connections.
+    #
+    # It does not proactively perform any I/O against the network
+    #
+    # @return [DiagnosticsResult]
+    def diagnostics(options = DiagnosticsOptions.new)
+      resp = @backend.diagnostics(options.report_id)
+      pp resp
+      DiagnosticsResult.new do |res|
+        res.version = resp[:version]
+        res.id = resp[:id]
+        res.sdk = resp[:sdk]
+        resp[:services].each do |type, svcs|
+          res.services[type] = svcs.map do |svc|
+            DiagnosticsResult::ServiceInfo.new do |info|
+              info.id = svc[:id]
+              info.state = svc[:state]
+              info.last_activity_us = svc[:last_activity_us]
+              info.remote = svc[:remote]
+              info.local = svc[:local]
+            end
+          end
+        end
+      end
+    end
 
     class ClusterOptions
       attr_accessor :authenticator
 
+      # @yieldparam [ClusterOptions] self
       def initialize
         yield self if block_given?
       end
@@ -243,232 +329,145 @@ module Couchbase
       end
     end
 
-    class QueryOptions
-      # @return [Integer] Timeout in milliseconds
-      attr_accessor :timeout
-
-      # @return [Boolean] Allows turning this request into a prepared statement query
-      attr_accessor :adhoc
-
-      # @return [String] Provides a custom client context ID for this query
-      attr_accessor :client_context_id
-
-      # @return [Integer] Allows overriding the default maximum parallelism for the query execution on the server side.
-      attr_accessor :max_parallelism
-
-      # @return [Boolean] Allows explicitly marking a query as being readonly and not mutating and documents on the server side.
-      attr_accessor :readonly
-
-      # Allows customizing how long (in milliseconds) the query engine is willing to wait until the index catches up to whatever scan consistency is asked for in this query.
-      #
-      # @note that if +:not_bounded+ consistency level is used, this method doesn't do anything
-      # at all. If no value is provided to this method, the server default is used.
-      #
-      # @return [Integer] The maximum duration (in milliseconds) the query engine is willing to wait before failing.
-      attr_accessor :scan_wait
-
-      # @return [Integer] Supports customizing the maximum buffered channel size between the indexer and the query service
-      attr_accessor :scan_cap
-
-      # @return [Integer] Supports customizing the number of items execution operators can batch for fetch from the KV layer on the server.
-      attr_accessor :pipeline_batch
-
-      # @return [Integer] Allows customizing the maximum number of items each execution operator can buffer between various operators on the server.
-      attr_accessor :pipeline_cap
-
-      # @return [Boolean] Enables per-request metrics in the trailing section of the query
-      attr_accessor :metrics
-
-      # @return [:off, :phases, :timings] Customize server profile level for this query
-      attr_accessor :profile
+    class DiagnosticsOptions
+      # @return [String] Holds custom report id.
+      attr_accessor :report_id
 
+      # @yieldparam [DiagnosticsOptions] self
       def initialize
-        @timeout = 75_000 # ms
-        @adhoc = true
-        @raw_parameters = {}
-        @positional_parameters = nil
-        @named_parameters = nil
-        @scan_consistency = nil
-        @mutation_state = nil
         yield self if block_given?
       end
-
-      # Allows providing custom JSON key/value pairs for advanced usage
-      #
-      # @param [String] key the parameter name (key of the JSON property)
-      # @param [Object] value the parameter value (value of the JSON property)
-      def raw(key, value)
-        @raw_parameters[key] = JSON.generate(value)
-      end
-
-      # Customizes the consistency guarantees for this query
-      #
-      # @note overrides consistency level set by {#consistent_with}
-      #
-      # [+:not_bounded+] The indexer will return whatever state it has to the query engine at the time of query. This is the default (for single-statement requests).
-      #
-      # [+:request_plus+] The indexer will wait until all mutations have been processed at the time of request before returning to the query engine.
-      #
-      # @param [:not_bounded, :request_plus] level the index scan consistency to be used for this query
-      def scan_consistency=(level)
-        @mutation_state = nil if @mutation_state
-        @scan_consistency = level
-      end
-
-      # Sets the mutation tokens this query should be consistent with
-      #
-      # @note overrides consistency level set by {#scan_consistency=}
-      #
-      # @param [MutationState] mutation_state the mutation state containing the mutation tokens
-      def consistent_with(mutation_state)
-        @scan_consistency = nil if @scan_consistency
-        @mutation_state = mutation_state
-      end
-
-      # Sets positional parameters for the query
-      #
-      # @param [Array] positional the list of parameters that have to be substituted in the statement
-      def positional_parameters(positional)
-        @positional_parameters = positional
-        @named_parameters = nil
-      end
-
-      # Sets named parameters for the query
-      #
-      # @param [Hash] named the key/value map of the parameters to substitute in the statement
-      def named_parameters(named)
-        @named_parameters = named
-        @positional_parameters = nil
-      end
     end
 
-    class QueryResult
-      # @return [QueryMetaData] returns object representing additional metadata associated with this query
-      attr_accessor :meta_data
-
-      attr_accessor :transcoder
-
-      # Returns all rows converted using a transcoder
-      #
-      # @return [Array]
-      def rows(transcoder = self.transcoder)
-        @rows.lazy.map do |row|
-          if transcoder == :json
-            JSON.parse(row)
-          else
-            transcoder.call(row)
-          end
+    class DiagnosticsResult
+      class ServiceInfo
+        # @return [String] endpoint unique identifier
+        attr_accessor :id
+
+        # Possible states are:
+        #
+        # :disconnected:: the endpoint is not reachable
+        # :connecting:: currently connecting (includes auth, handshake, etc.)
+        # :connected:: connected and ready
+        # :disconnecting:: disconnecting (after being connected)
+        #
+        # @return [Symbol] state of the endpoint
+        attr_accessor :state
+
+        # @return [Integer] how long ago the endpoint was active (in microseconds)
+        attr_accessor :last_activity_us
+
+        # @return [String] remote address of the connection
+        attr_accessor :remote
+
+        # @return [String] local address of the connection
+        attr_accessor :local
+
+        # @yieldparam [ServiceInfo] self
+        def initialize
+          yield self if block_given?
         end
-      end
-
-      # @yieldparam [QueryResult] self
-      def initialize
-        yield self if block_given?
-        @transcoder = :json
-      end
-    end
-
-    class QueryMetaData
-      # @return [String] returns the request identifier string of the query request
-      attr_accessor :request_id
-
-      # @return [String] returns the client context identifier string set of the query request
-      attr_accessor :client_context_id
-
-      # @return [Symbol] returns raw query execution status as returned by the query engine
-      attr_accessor :status
-
-      # @return [Hash] returns the signature as returned by the query engine which is then decoded as JSON object
-      attr_accessor :signature
-
-      # @return [Hash] returns the profiling information returned by the query engine which is then decoded as JSON object
-      attr_accessor :profile
-
-      # @return [QueryMetrics] metrics as returned by the query engine, if enabled
-      attr_accessor :metrics
-
-      # @return [List<QueryWarning>] list of warnings returned by the query engine
-      attr_accessor :warnings
-
-      # @yieldparam [QueryMetaData] self
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class QueryMetrics
-      # @return [Integer] The total time taken for the request, that is the time from when the request was received until the results were returned
-      attr_accessor :elapsed_time
-
-      # @return [Integer] The time taken for the execution of the request, that is the time from when query execution started until the results were returned
-      attr_accessor :execution_time
-
-      # @return [Integer] the total number of results selected by the engine before restriction through LIMIT clause.
-      attr_accessor :sort_count
-
-      # @return [Integer] The total number of objects in the results.
-      attr_accessor :result_count
-
-      # @return [Integer] The total number of bytes in the results.
-      attr_accessor :result_size
-
-      # @return [Integer] The number of mutations that were made during the request.
-      attr_accessor :mutation_count
 
-      # @return [Integer] The number of errors that occurred during the request.
-      attr_accessor :error_count
-
-      # @return [Integer] The number of warnings that occurred during the request.
-      attr_accessor :warning_count
-
-      # @yieldparam [QueryMetrics] self
-      def initialize
-        yield self if block_given?
+        def to_json(*args)
+          data = {
+            id: @id,
+            state: @state,
+            remote: @remote,
+            local: @local,
+          }
+          data[:last_activity_us] = @last_activity_us if defined? @last_activity_us
+          data.to_json(*args)
+        end
       end
-    end
 
-    # Represents a single warning returned from the query engine.
-    class QueryWarning
-      # @return [Integer]
-      attr_accessor :code
+      # @return [String] report id
+      attr_accessor :id
 
-      # @return [String]
-      attr_accessor :message
+      # @return [String] SDK identifier
+      attr_accessor :sdk
 
-      def initialize(code, message)
-        @code = code
-        @message = message
-      end
-    end
+      # Returns information about currently service endpoints, that known to the library at the moment.
+      #
+      # :kv:: Key/Value data service
+      # :query:: N1QL query service
+      # :analytics:: Analtyics service
+      # :search:: Full text search service
+      # :views:: Views service
+      # :mgmt:: Management service
+      #
+      # @return [Hash<Symbol, ServiceInfo>] map service types to info
+      attr_accessor :services
 
-    class AnalyticsOptions
+      # @yieldparam [DiagnosticsResult] self
       def initialize
+        @services = Hash.new
         yield self if block_given?
       end
-    end
-
-    class DiagnosticsOptions
-      # @return [String] Holds custom report id.
-      attr_accessor :report_id
 
-      def initialize
-        yield self if block_given?
+      # @api private
+      # @return [Integer] version
+      attr_accessor :version
+
+      def to_json(*args)
+        {
+          version: @version,
+          id: @id,
+          sdk: @sdk,
+          services: @services,
+        }.to_json(*args)
       end
     end
 
     private
 
-    def initialize(connection_string, options)
-      hostname = connection_string[%r{^couchbase://(.*)}, 1]
-      raise ArgumentError, "missing hostname" unless hostname
-      raise ArgumentError, "options must have authenticator configured" unless options.authenticator
-      username = options.authenticator.username
-      raise ArgumentError, "missing username" unless username
-      password = options.authenticator.password
-      raise ArgumentError, "missing password" unless password
+    # Initialize {Cluster} object
+    #
+    # @overload new(connection_string, options)
+    #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+    #   @param [ClusterOptions] options custom options when creating the cluster connection
+    #
+    # @overload new(connection_string, username, password, options)
+    #   Shortcut for {PasswordAuthenticator}
+    #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+    #   @param [String] username name of the user
+    #   @param [String] password password of the user
+    #   @param [ClusterOptions, nil] options custom options when creating the cluster connection
+    def initialize(connection_string, *args)
+      credentials = {}
+
+      options = args.shift
+      case options
+      when String
+        credentials[:username] = options
+        credentials[:password] = args.shift
+        raise ArgumentError, "missing username" unless credentials[:username]
+        raise ArgumentError, "missing password" unless credentials[:password]
+      when ClusterOptions
+        authenticator = options&.authenticator
+        case authenticator
+        when PasswordAuthenticator
+          credentials[:username] = authenticator&.username
+          raise ArgumentError, "missing username" unless credentials[:username]
+
+          credentials[:password] = authenticator&.password
+          raise ArgumentError, "missing password" unless credentials[:password]
+
+        when CertificateAuthenticator
+          credentials[:certificate_path] = authenticator&.certificate_path
+          raise ArgumentError, "missing certificate path" unless credentials[:certificate_path]
+
+          credentials[:key_path] = authenticator&.key_path
+          raise ArgumentError, "missing key path" unless credentials[:key_path]
+
+        else
+          raise ArgumentError, "options must have authenticator configured"
+        end
+      else
+        raise ArgumentError, "unexpected second argument, have to be String or ClusterOptions"
+      end
 
       @backend = Backend.new
-      @backend.open(hostname, username, password)
+      @backend.open(connection_string, credentials, {})
     end
   end
 end