Method initialize has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def initialize(address, config = {}, average_round_trip_time: nil,
        load_balancer: false, force_load_balancer: false
      )
        @address = address
        @config = config

Method try_next has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def try_next
      if @documents.nil?
        # Since published versions of Mongoid have a copy of old driver cursor
        # code, our dup call in #process isn't invoked when Mongoid query
        # cache is active. Work around that by also calling dup here on

Method add_read_preference has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def add_read_preference(sel, connection)
        Lint.assert_type(connection, Server::Connection)

        # https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.rst#topology-type-single
        read_doc = if connection.description.standalone?

Method update_rs_without_primary has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def update_rs_without_primary
      if topology.replica_set_name.nil?
        @topology = Topology::ReplicaSetNoPrimary.new(
          topology.options.merge(replica_set_name: updated_desc.replica_set_name),
          topology.monitoring, self)

Method distinct has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def distinct(field_name, opts = {})
          if field_name.nil?
            raise ArgumentError, 'Field name for distinct operation must be not nil'
          end
          opts = @options.merge(opts) unless Mongo.broken_view_options

Method add has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def add(host, add_options=nil)
      address = Address.new(host, options)
      if !addresses.include?(address)
        opts = options.merge(monitor: false)
        # If we aren't starting the montoring threads, we also don't want to

• Read up
  Read up

Method wait_for_connection has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      def wait_for_connection(connection_global_id, deadline)
        connection = nil
        while connection.nil?
          # The second gate to checking out a connection. Make sure 1) there
          # exists an available connection and 2) we are under max_connecting.

• Read up
  Read up

Method ec2_metadata_credentials has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

        def ec2_metadata_credentials
          http = Net::HTTP.new('169.254.169.254')
          req = Net::HTTP::Put.new('/latest/api/token',
            # The TTL is required in order to obtain the metadata token.
            {'x-aws-ec2-metadata-token-ttl-seconds' => '30'})

• Read up
  Read up

Method retrieve_and_connect_connection has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      def retrieve_and_connect_connection(connection_global_id)
        deadline = Utils.monotonic_time + wait_timeout
        connection = nil

        @lock.synchronize do

• Read up
  Read up

Method credentials_valid? has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

        def credentials_valid?(credentials, source)
          unless credentials.access_key_id || credentials.secret_access_key ||
            credentials.session_token
          then
            return false

• Read up
  Read up

Method check has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      def check
        if @connection && @connection.pid != Process.pid
          log_warn("Detected PID change - Mongo client should have been reconnected (old pid #{@connection.pid}, new pid #{Process.pid}")
          @connection.disconnect!
          @connection = nil

• Read up
  Read up

Method validate_read_concern_option has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def validate_read_concern_option(read_concern)
      return unless enabled?
      return if read_concern.nil?
      unless read_concern.is_a?(Hash)
        raise Error::LintError, "Read concern is not a hash: #{read_concern}"

• Read up
  Read up

Method read has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def read(length, timeout: nil)
      map_exceptions do
        data = read_from_socket(length, timeout: timeout)
        unless (data.length > 0 || length == 0)
          raise IOError, "Expected to read > 0 bytes but read 0 bytes"

• Read up
  Read up

Method update_many has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

        def update_many(spec, opts = {})
          with_session(opts) do |session|
            write_concern = if opts[:write_concern]
              WriteConcern.get(opts[:write_concern])
            else

• Read up
  Read up

Method command has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      def command(connection)
        if Lint.enabled?
          unless connection.is_a?(Server::Connection)
            raise Error::LintError, "Connection is not a Connection instance: #{connection}"
          end

• Read up
  Read up

Method add_read_preference_legacy has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      def add_read_preference_legacy(sel, connection)
        if read && (
          connection.description.mongos? || connection.description.load_balancer?
        ) && read_pref = read.to_mongos
          # If the read preference contains only mode and mode is secondary

• Read up
  Read up

Method apply_session_options has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      def apply_session_options(sel, connection)
        apply_cluster_time!(sel, connection)
        sel[:txnNumber] = BSON::Int64.new(txn_num) if txn_num
        sel.merge!(lsid: session.session_id)
        apply_start_transaction!(sel)

• Read up
  Read up

Method replace_one has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

        def replace_one(replacement, opts = {})
          with_session(opts) do |session|
            write_concern = if opts[:write_concern]
              WriteConcern.get(opts[:write_concern])
            else

• Read up
  Read up

Method parse_password! has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def parse_password!(string)
      if (string && pwd = string.partition(AUTH_USER_PWD_DELIM)[2])
        if pwd.length > 0
          raise_invalid_error!(UNESCAPED_USER_PWD) if pwd =~ UNSAFE
          pwd_decoded = decode(pwd)

• Read up
  Read up

Method effective_read_preference has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

        def effective_read_preference(connection)
          return unless view.read_preference
          return view.read_preference unless write?
          return view.read_preference unless [:secondary, :secondary_preferred].include?(view.read_preference[:mode])

• Read up
  Read up