redis.debug_mode = true
185612
function Queue (name, redisClient) {
  this.hasQuit = false
  this._name = name
  this.redisClient = redisClient
  this._key = Queue.PREFIX + this.name
}
74489
def debug(msg = nil)
      if @logger
        msg = build_log(msg || yield, ActionCommand::LOG_KIND_DEBUG)
        @logger.info(format_log(msg))
      end
    end
195848
def _redis_connect(cls, settings):
        
        if 'tornadoredis' not in globals():
            import tornadoredis
        kwargs = {'host': settings.get('host', cls.REDIS_HOST),
                  'port': settings.get('port', cls.REDIS_PORT),
                  'selected_db': settings.get('db', cls.REDIS_DB)}
        LOGGER.info('Connecting to %(host)s:%(port)s DB %(selected_db)s',
                    kwargs)
        cls._redis_client = tornadoredis.Client(**kwargs)
        cls._redis_client.connect()
1098062
def with_debug_id(debug_id):
        """"""
        ctx = SpanContext(
            trace_id=None, span_id=None, parent_id=None, flags=None
        )
        ctx._debug_id = debug_id
        return ctx
912487
def debug(message)
      (m = filter(message, :debug)) && each {|l| l.debug(m)}
    end
1319828
def switch_mode(app, mode)
      mode = nil if mode == "none"
      mode = "run" if mode == "" # no value given

      return false if app.debug == mode

      if mode.nil?
        with_progress("Removing debug mode") do
          app.debug = nil
          app.stop! if app.started?
        end

        return true
      end

      with_progress("Switching mode to #{c(mode, :name)}") do |s|
        app.debug = mode
        app.stop! if app.started?
      end
    end
980951
async def debug(self, conn_id, name, cmd_args):
        

        adapter_id = self._get_property(conn_id, 'adapter')
        return await self.adapters[adapter_id].debug(conn_id, name, cmd_args)
350309
def is_delayed(self) -> bool:
        """"""
        if not self.redis_key_delayed:
            return False

        value = self._red.get(self.redis_key_delayed)
        if not value:
            return False

        return True
1232661
def parse_debug_object(response):
    ""
    # The 'type' of the object is the first item in the response, but isn't
    # prefixed with a name
    response = nativestr(response)
    response = 'type:' + response
    response = dict([kv.split(':') for kv in response.split()])

    # parse some expected int values from the string response
    # note: this cmd isn't spec'd so these may not appear in all redis versions
    int_fields = ('refcount', 'serializedlength', 'lru', 'lru_seconds_idle')
    for field in int_fields:
        if field in response:
            response[field] = int(response[field])

    return response
171020
def debug(self, debug_commands):
    """"""
    if isinstance(debug_commands, sc_debug.DebugCommand):
      debug_commands = [debug_commands]
    return self._client.send(debug=sc_pb.RequestDebug(debug=debug_commands))
463359
def debug_msg(message):
        
        message = message or ""
        if Console.color:
            Console.cprint('RED', 'DEBUG: ', message)
        else:
            print(Console.msg('DEBUG: ' + message))
85869
def debug(self):
        """"""
        debug = False
        if os.path.isfile(os.path.join(self.tcex.args.tc_temp_path, 'DEBUG')):
            debug = True
        return debug
156609
function debug( err, req, res, next ) {
        res.status( err.status || 500 );

        err.guid = uuid.v4();

        console.error( err );

        res.json( {
            error: err.message,
            message: err.userMessage,
            handled: err.handled || false,
            guid: err.guid,
            stack: err.stack
        } );
    }
1321503
def printd(*args, **kwargs):
    """"""

    global settings
    if settings['PRINT_DEBUG_STATE']:
        print(*args, **kwargs)
        return True
    return False
1020635
def _debug(self, message, load=False, no_prefix=False):
        
        if self.args.debug_analysis:
            if load:
                message = '\r\n'.join(
                    ['# ' + line for line in message.strip().split('\r\n')]
                )
                print '{0}\n{1}\n{0}'.format('#' * 78, message)
            else:
                # If open message and no_prefix is False
                if (len(self.messages) > 0 and not
                        self.messages[-1].write_closed) and not no_prefix:
                    print '--OPEN--> {0}'.format(message)
                else:
                    print message
900031
def check_redis():
        
        from pyoko.db.connection import cache
        from redis.exceptions import ConnectionError

        try:
            cache.ping()
            print(CheckList.OKGREEN + "{0}Redis is working{1}" + CheckList.ENDC)
        except ConnectionError as e:
            print(__(u"{0}Redis is not working{1} ").format(CheckList.FAIL,
                                                            CheckList.ENDC), e.message)
109976
def debug
      ::RSpec.configure do |config|
        config.add_setting :debugger_proc
        config.debugger_proc = ->(ex) do
          exception = ex.exception
          defined?(Pry) ? binding.pry : debugger # rubocop:disable Debugger
        end
        config.after(debug: true) do |ex|
          instance_exec(ex, &config.debugger_proc) if ex.exception
        end
      end
    end