Debug
@param {String} className
@param {String} msg The message text (including arguments)
@param {String} msgText The message text (before arguments were replaced)
@param {Object} o An optional object to be inspected
332681
function (className, msg, msgText, o) {
                if (console.debug) {
                    console.debug(this._formatClassName(className) + msg);
                } else if (console.log) {
                    console.log(this._formatClassName(className) + msg);
                }
                this._inspectObject(o);
            }
1203163
private static boolean isLegalMessageVarAlias(Node msgNode, String msgKey) {
    if (msgNode.isGetProp()
        && msgNode.isQualifiedName()
        && msgNode.getLastChild().getString().equals(msgKey)) {
      // Case: `foo.Thing.MSG_EXAMPLE = bar.OtherThing.MSG_EXAMPLE;`
      //
      // This kind of construct is created by Es6ToEs3ClassSideInheritance. Just ignore it; the
      // message will have already been extracted from the base class.
      return true;
    }

    if (msgNode.getGrandparent().isObjectPattern() && msgNode.isName()) {
      // Case: `var {MSG_HELLO} = x;
      //
      // It's a destructuring import. Ignore it if the name is the same. We compare against the
      // original name if possible because in modules, the NAME node will be rewritten with a
      // module-qualified name (e.g. `var {MSG_HELLO: goog$module$my$module_MSG_HELLO} = x;`).
      String aliasName =
          (msgNode.getOriginalName() != null) ? msgNode.getOriginalName() : msgNode.getString();
      if (aliasName.equals(msgKey)) {
        return true;
      }
    }

    // TODO(nickreid): Should `var MSG_HELLO = x.MSG_HELLO;` also be allowed?

    return false;
  }
711974
public void debug(String format, Object arg1, Object arg2) {
        if (!logger.isDebugEnabled())
            return;

        if (instanceofLAL) {
            String formattedMessage = MessageFormatter.format(format, arg1, arg2).getMessage();
            ((LocationAwareLogger) logger).log(null, fqcn, LocationAwareLogger.DEBUG_INT, formattedMessage, new Object[] { arg1, arg2 }, null);
        } else {
            logger.debug(format, arg1, arg2);
        }
    }
1103345
public static void d(String msg) {
		if (!debug) {
			return;
		}
		if (messager == null) {
			return;
		}
		messager.printMessage(Diagnostic.Kind.NOTE, msg);
	}
322936
@Override
    public void debug(String format, Object arg) {
        if (logger.isDebugEnabled()) {
            FormattingTuple ft = MessageFormatter.format(format, arg);
            logger.debug(ft.getMessage(), ft.getThrowable());
        }
    }
386324
public static function dompdf_debug($type, $msg)
    {
        global $_DOMPDF_DEBUG_TYPES, $_dompdf_show_warnings, $_dompdf_debug;
        if (isset($_DOMPDF_DEBUG_TYPES[$type]) && ($_dompdf_show_warnings || $_dompdf_debug)) {
            $arr = debug_backtrace();

            echo basename($arr[0]["file"]) . " (" . $arr[0]["line"] . "): " . $arr[1]["function"] . ": ";
            Helpers::pre_r($msg);
        }
    }
507408
function (className, functionName, message) {
            var msg = this.messageTable[message] ? this.messageTable[message] : message;

            return className + "." + functionName + ": " + msg;
        }
857129
public final static void debug(Object... msg)
    {
        if ( DEBUG.get() ) {
            StringBuilder sb = new StringBuilder();
            for ( Object m : msg )
                sb.append(m);
            Console.debug.println("// Debug: " + sb.toString());
        }
    }
341853
function _onMessage(message) {
        var response    = JSON.parse(message.data),
            msgRecord   = _messageCallbacks[response.id],
            callback    = msgRecord && msgRecord.callback,
            msgText     = (msgRecord && msgRecord.message) || "No message";

        if (msgRecord) {
            // Messages with an ID are a response to a command, fire callback
            callback(response.result, response.error);
            delete _messageCallbacks[response.id];
        } else if (response.method) {
            // Messages with a method are an event, trigger event handlers
            var domainAndMethod = response.method.split("."),
                domain = domainAndMethod[0],
                method = domainAndMethod[1];

            EventDispatcher.triggerWithArray(exports[domain], method, response.params);
        }

        // Always fire event handlers for all messages/errors
        exports.trigger("message", response);

        if (response.error) {
            exports.trigger("error", response.error, msgText);
        }
    }
525314
public static void debug(String msg) {
        if (debugEnabled && !quietMode) {
            System.out.println(PREFIX + msg);
        }
    }
134195
public final void debug(Object source, Class sourceClass, String methodName, Object object)
    {
        debug(source, sourceClass, methodName, new Object[] { object });
    }
261542
@Override
    public void debug(String msg, Throwable e) {
        log.logIfEnabled(FQCN, Level.DEBUG, null, msg, e);
    }
1258419
function (classpath, msg) {
            this._logs[this._nbLogs++] = {
                classpath : classpath,
                msg : msg,
                timestamp : (new Date()).getTime()
            };
        }
401600
function printDebugWithCode(msg, code) {
  // eslint-disable-next-line no-console
  console.log(`\n\n${msg}:\n`);
  // eslint-disable-next-line no-console
  console.log(`${highlightFn(code)}\n`);
}
896430
function (level, className, functionName, message) {
            var msg = this.makeMessage(className, functionName, message);
            this.log(level, msg);

            return msg;
        }
150089
public void debug(Object format, Object... msg) {
		if (logger.isDebugEnabled()) {
			// check if the first message contains variables variables
			if (format.toString().contains("{")) {
				logger.debug(format.toString(), msg);
			} else {
				logger.debug(format.toString().concat(" ").concat(JKStringUtil.concat(msg)));
			}
		}
	}
795474
def debug(self, text):
		
		self.logger.debug("{}{}".format(self.message_prefix, text))