Enable or disable the debug logging.
 @param [Boolean] enable Enable or disable the debug logging.
321078
def enable_debug_logging=(enable)
      return if enable.nil?
      logging = REXML::XPath.first(@xml, 'ScanTemplate/Logging')
      if logging.nil?
        logging = REXML::Element.new('Logging')
        @xml.add_element(logging)
      end
      debug_logging = REXML::XPath.first(logging, 'debugLogging')
      if debug_logging.nil?
        debug_logging = REXML::Element.new('debugLogging')
        logging.add_element(debug_logging)
      end
      debug_logging.attributes['enabled'] = (enable ? 1 : 0)
    end
1016608
public void enableFullLogging() {
    enable(DB.Option.LOG_ASSERTION_ERRORS,
        DB.Option.LOG_ASSERTIONS,
        DB.Option.LOG_SETUP,
        DB.Option.LOG_QUERIES,
        DB.Option.LOG_SNAPSHOTS,
        DB.Option.LOG_DATABASE_EXCEPTIONS);
  }
551476
function enableDebugger() {
        try {
            _nodeConnection.domains.base.enableDebugger();
        } catch (e) {
            window.alert("Failed trying to enable Node debugger: " + e.message);
        }
    }
1315545
def log_setup(debug_bool):
    

    level = logging.DEBUG if debug_bool else logging.INFO

    logging.config.dictConfig(
        {
            "version": 1,
            "disable_existing_loggers": False,
            "formatters": {
                "verbose": {
                    "format": "%(asctime)s %(levelname)-8s %(name)s %(module)s "
                    "%(process)d %(thread)d %(message)s",
                    "datefmt": "%Y-%m-%d %H:%M:%S",
                }
            },
            "handlers": {
                "console": {
                    "class": "logging.StreamHandler",
                    "formatter": "verbose",
                    "level": level,
                    "stream": "ext://sys.stdout",
                }
            },
            "loggers": {
                "": {
                    "handlers": ["console"],
                    "level": level,
                    "class": "logging.StreamHandler",
                }
            },
        }
    )
237046
def activate_debug():
    
    ch = logging.StreamHandler()
    ch.setLevel(logging.DEBUG)
    logger.addHandler(ch)
    logger.setLevel(logging.DEBUG)
629534
function yep(options) {
  /**
   * The function that receives the actual debug information.
   *
   * @returns {Boolean} indication that we're logging.
   * @public
   */
  function diagnostics() {
    var args = Array.prototype.slice.call(arguments, 0);

    write.call(write, options, process(args, options));
    return true;
  }

  options.enabled = true;
  options.modify = modify;
  options.set = set;
  options.use = use;

  return introduce(diagnostics, options);
}
1188861
function(enable) {
    if (enable === undefined) {
      return this._rockAndRoll !== null;
    }
    if (!!enable) {
      if (this._rockAndRoll === null) {
        this._rockAndRoll = anim.rockAndRoll();
        this._animControl.add(this._rockAndRoll);
        this.requestRedraw();
      }
      return true;
    } 
    this._animControl.remove(this._rockAndRoll);
    this._rockAndRoll = null;
    this.requestRedraw();
    return false;
  }
975390
def debug(self, message, *args, **kwargs):
        
        self._log(logging.DEBUG, message, *args, **kwargs)
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
826155
public synchronized void setDebug(boolean debug)
    {
        boolean oldDebug=_debugOn;
        if (_debugOn && !debug)
            this.message(DEBUG,"DEBUG OFF");
        _debugOn=debug;
        if (!oldDebug && debug)
            this.message(DEBUG,"DEBUG ON");
    }
452184
def set_debug(self, set_to=True):
        
        if set_to:
            StreamHandler(sys.stdout).push_application()
            self._log.level = logbook.DEBUG
        self.debug = set_to
684774
public void setEnabled(boolean enabled) {
		if (enabled && engine == null) {
			return;
		}

		if (this.enabled != enabled) {
			this.enabled = enabled;
			this.changed = true;
		}
	}
163534
def disable_logging(logger=None):
    
    logger = logger or logging.getLogger()
    disabled = logger.disabled
    logger.disabled = True
    yield
    logger.disabled = disabled
715597
public static function enable(): void
    {
        self::$debugbar = new StandardDebugBar();
        self::$debugbar->addCollector(new ViewCollector());

        self::$renderer = self::$debugbar->getJavascriptRenderer('./vendor/maximebf/debugbar/src/DebugBar/Resources/');
    }
661618
public function enableDebugLog()
    {
        if ($this->log !== null) {
            // Debug log byl již zapnut dříve.
            return;
        }

        $this->log = [];
        $logger = function (SkautisQuery $query) {
            $this->log[] = $query;
        };
        $this->wsdlManager->addWebServiceListener(WebService::EVENT_SUCCESS, $logger);
        $this->wsdlManager->addWebServiceListener(WebService::EVENT_FAILURE, $logger);
    }
627300
def debug(dbg=True):
    """"""
    global _debug_handler
    if dbg and _debug_handler is None:
        _debug_handler = logging.StreamHandler()
        logger.addHandler(_debug_handler)
        logger.setLevel(logging.DEBUG)
    elif not dbg and _debug_handler is not None:
        logger.removeHandler(_debug_handler)
        _debug_handler = None
        logger.setLevel(logging.WARNING)
505380
def set(self, mode, disable):
        
        global logger
        try:
            if logger:
                if disable:
                    logger.disabled = True
            else:
                if mode in ('STREAM', 'FILE'):
                    logger = logd.getLogger(mode, __version__)
        except Exception as e:
            logger.exception(
                '%s: Problem incurred during logging setup' % inspect.stack()[0][3]
                )
            return False
        return True