Nice Way to get Logger for multipurposes. Idea as ported from python Logging

Logger.java

import java.lang.StringBuilder;
import hudson.model.TaskListener;
import java.lang.reflect.Field;

class Logger {

    public enum Level {
        WTF(55), CRITICAL(50), ERROR(40), WARNING(30), INFO(20), DEBUG(10), NOSET(0);

        private final int level;

        private Level(int logginLevel) {
            this.level = logginLevel;
        }

        public boolean validLevel(Level checkLevel) {
            return 0 < this.level && this.level<= checkLevel.level ;
        }
    }

    private static TaskListener listener;
    private static Level logLevel;

    public static void setListener(TaskListener listener) {
        Logger.listener = listener;
    }

    public static void wtf(String message) {
        if (Logger.logLevel.validLevel(Level.WTF))
            Logger.println("[¡¿*?!] WTF  :: %s", message);
    }

    public static void critical(String message) {
        if (Logger.logLevel.validLevel(Level.CRITICAL))
            Logger.println("[¡!] CRITICAL :: %s ", message);
    }

    public static void error(String message) {
        if (Logger.logLevel.validLevel(Level.ERROR))
            Logger.println(message);
    }

    public static void warn(String message) {
        if (Logger.logLevel.validLevel(Level.WARNING))
            Logger.println("[¿?] WARNING  :: %s", message);
    }

    public static void warning(String message) {
        Logger.warn(message);
    }

    public static void info(String message) {
        if (Logger.logLevel.validLevel(Level.INFO))
            Logger.println("[**] INFO  :: %s", message);
    }

    public static void debug(String message) {
        if (Logger.logLevel.validLevel(Level.DEBUG))
            Logger.println("[+-] DEBUG  :: %s", message);
    }


    public static void debug(String message, Object... args) {
           Logger.debug(String.format(message, args));
    }

    public static void debug(String message, Object obj){
        Logger.debug(message + "\r\n" + Logger.objectToString(obj));
    }

    public static void debug(Object obj){
        Logger.debug(Logger.objectToString(obj));
    }


    private static String objectToString(Object obj)
    {
        StringBuilder result = new StringBuilder("Printing object\n");
        // result.append(obj.getClass().getCanonicalName() + "\n");

        try {
            String newLine = System.getProperty("line.separator");

            result.append(obj.getClass().getName());
            result.append(" Object {");
            result.append(newLine);

            // determine fields declared in obj class only (no fields of superclass)
            Field[] fields = obj.getClass().getDeclaredFields();

            // print field names paired with their values
            for (Field field : fields) {
                result.append("  ");
                try {
                    result.append(field.getName());
                    result.append(": ");
                    field.setAccessible(true);
                    // requires access to private field:
                    result.append(field.get(obj));
                } catch (IllegalAccessException ex) {
                    System.out.println(ex);
                }
                result.append(newLine);
            }
            result.append("}");
        } catch (Exception ex) {
            result.append("Unable to get attributes: " + ex.getMessage());
        }
        return result.toString();    
    }


    public static void println(String message, Object... args) {
        /**
        * Here you can substitute with our stdout redirection using String.format
        * And need to handle if (stdout stream is null) we defined as TaskListener, because is used as Jenkins Plugins logger
        */
        if (Logger.listener != null)
            Logger.listener.getLogger().println(String.format(message, args));
    }

    public static void enableDebug() {
        Logger.setLevel(Level.DEBUG);
    }

    public static void disableDebug() {
        Logger.setLevel(Level.INFO);
    }

    public static void setLevel(Level logLevel) {
        Logger.logLevel = logLevel;
    }
}