Log any one or more of a message, an exception and structured data as TRACE.
 @return [Boolean] true
 @see Logging#debug
770218
def trace(message = nil, ex = nil, data = nil, &block)
      log(TRACE, message, ex, data, block)
    end
21360
def trace_on(out, *strings)
      sep = $\ || "\n"
      if strings.empty?
        output = sep
      else
        output = strings.map { |s|
          next if s.nil?
          s =~ /#{sep}$/ ? s : s + sep
        }.join
      end
      out.print(output)
    end
884736
def showLogging(debug=False):
    

    try:
        log_level = logging.WARN
        log_format = LOG_FORMAT_DEBUG
        if debug:
            log_level = logging.DEBUG
        logging.basicConfig(
            level=log_level,
            format=log_format)
    except:
        logging.basicConfig()
709044
def do_debug(self, arg):
        
        self.settrace(False)
        globals = self.curframe.f_globals
        locals = self.get_locals(self.curframe)
        p = Pdb(self.completekey, self.stdin, self.stdout, debug=True)
        p.prompt = "(%s) " % self.prompt.strip()
        self.message("ENTERING RECURSIVE DEBUGGER")
        sys.call_tracing(p.run, (arg, globals, locals))
        self.message("LEAVING RECURSIVE DEBUGGER")
        self.settrace(True)
        self.lastcmd = p.lastcmd
201751
def log(method_list)
      method_list = Array[method_list]
      method_list.each do |method|
        backup_name = "#{method}_bak".to_sym
        alias_method :backup_name, :method
        define_method(method) do |*args|
          Display.debug("##{method}: ")
          Display.debug(args.inspect)
        end
      end
    end
417469
def verbose
      if Calabash::Logger.log_levels.include?(:debug)
        puts Color.blue('Debug logging is already turned on.')
      else
        Calabash::Logger.log_levels << :debug
        puts Color.blue('Turned on debug logging.')
      end

      true
    end
643600
def trace_debug_dispatch(self, frame, event, arg):
        """"""
        trace_log.info(
            'Frame:%s. Event: %s. Arg: %r' % (pretty_frame(frame), event, arg)
        )
        trace_log.debug(
            'state %r breaks ? %s stops ? %s' % (
                self.state, self.breaks(frame, no_remove=True),
                self.state.stops(frame, event)
            )
        )
        if event == 'return':
            trace_log.debug(
                'Return: frame: %s, state: %s, state.f_back: %s' % (
                    pretty_frame(frame), pretty_frame(self.state.frame),
                    pretty_frame(self.state.frame.f_back)
                )
            )
        if self.trace_dispatch(frame, event, arg):
            return self.trace_debug_dispatch
        trace_log.debug("No trace %s" % pretty_frame(frame))
106644
def debug(msg)
      # Should probably replace with a Logger
      return unless config.debug_filename

      @debug ||= File.open(config.debug_filename, 'w')
      @debug.write("#{msg}\n")
      @debug.flush
    end
631432
@Override
    public void trace(String msg, Throwable t) {
        logger.log(FQCN, traceCapable ? Level.TRACE : Level.DEBUG, msg, t);
    }
74489
def debug(msg = nil)
      if @logger
        msg = build_log(msg || yield, ActionCommand::LOG_KIND_DEBUG)
        @logger.info(format_log(msg))
      end
    end
1091165
def log(messages, event = :debug, level = event)
      messages = Array(messages).map {|m| filter(m, event)}.compact
      each {|l| l.log(messages, event, level)}
    end
820877
def log_errors!
      if AnyCable.config.debug?
        # Print error with backtrace in debug mode
        AnyCable.capture_exception do |e|
          AnyCable.logger.error("#{e.message}:\n#{e.backtrace.take(20).join("\n")}")
        end
      else
        AnyCable.capture_exception { |e| AnyCable.logger.error(e.message) }
      end
    end
753050
def log(self, cause=None, do_message=True, custom_msg=None):
        
        message = error_message(self, cause=cause)
        exc_type, exc_value, exc_traceback = sys.exc_info()
        traceback_formatted = traceback.format_exc()
        traceback_val = traceback.extract_tb(exc_traceback)

        md5 = hashlib.md5(traceback_formatted.encode('utf-8')).hexdigest()

        if md5 in self._db:
            # self.logger.debug('Exception trace logged: %s' % md5)
            return

        if custom_msg is not None and cause is not None:
            self.logger.debug('%s : %s' % (custom_msg, cause))
        elif custom_msg is not None:
            self.logger.debug(custom_msg)
        elif cause is not None:
            self.logger.debug('%s' % cause)

        self.logger.debug(traceback_formatted)
        self._db.add(md5)
1013763
def debug(self, state=None):
        
        if state is None:
            return self.__debug
        self.__debug = bool(state)
        return self.__debug
575288
def debug(self, message, *args, **kwargs):
        
        self.system.debug(message, *args, **kwargs)
719961
def debug(self, message, extra={}):
        '''
        
        '''
        if self.level_dict['DEBUG'] >= self.level_dict[self.log_level]:
            extras = self.add_extras(extra, "DEBUG")
            self._write_message(message, extras)
            self.fire_callbacks('DEBUG', message, extra)
745458
def debug(message, level=1):
    
    if level <= debug_level:
        logging.debug(' ' * (level - 1) * 2 + str(message))