At least for my feelings somehow the creators of Log4J forgot to add a security level as one of the default log levels in Log4J. It is easy to add a new log level to Log4J and whith Groovy it gets (as usual) even more easy. Let’s see how:

static {

    ...

    static final Level SECURITY = new Level(45000, "SECURITY", 08)

    Object.metaClass.static.logSecurity = { Object msg, Throwable ex = null ->
      delegate.logger.log(logger.FQCN, SECURITY, msg, ex)
    }
}

Now you can say http://groovypy.wordpress.com/wp-admin/post-new.php#edit_timestamp

logSecurity 'Insecure user detected'

in your code. If you think ‘SECURITY’ should be added to the Level class you feel like me. Unfortunately Groovy does not allow this with its current metaobject protocol implementation.

import org.apache.log4j.Logger;

class Foo {
  private final Logger log = Logger.getLogger(this.getClass());
}

In Java I repeated this in every and all of my classes. Now working almost only with Groovy this does not feel right anymore. It does not feel DRY. My solution is to have a static initializer block in one class to teach all my objects how to log. This, like the Java variant above, is limited to instance logging. As I avoid static methods this works for me.

import org.apache.log4j.*

static {
	def logPattern = new PatternLayout('%r %-5p [%c{1}] %m%n')
	def level = Level.TRACE
	BasicConfigurator.configure(new ConsoleAppender(logPattern))
	BasicConfigurator.configure(new FileAppender(logPattern, "${applicationName}.log"))
	LogManager.rootLogger.level = level

	Object.metaClass.static.getLogger = {
		-> Logger.getLogger(delegate.class)
	}
	Object.metaClass.static.logTrace = { Object msg, Throwable ex = null ->
		delegate.logger.trace msg, ex
	}
	Object.metaClass.static.logDebug = { Object msg, Throwable ex = null ->
		delegate.logger.debug msg, ex
	}
	Object.metaClass.static.logInfo = { Object msg, Throwable ex = null ->
		delegate.logger.info msg, ex
	}
	Object.metaClass.static.logWarn = { Object msg, Throwable ex = null ->
		delegate.logger.warn msg, ex
	}
	Object.metaClass.static.logError = { Object msg, Throwable ex = null ->
		delegate.logger.error msg, ex
	}
	Object.metaClass.static.logFatal = { Object msg, Throwable ex = null ->
		delegate.logger.fatal msg, ex
	}
}

You have now added the static methods getLogger, logTrace, logDebug, logInfo, logWarn, logError and logFatal to the class Object. With this in place you can now log in any instance method without importing anything:

logTrace "${applicationName} start at: ${Calendar.instance.time}"
logWarn 'Too many bad fingers on keyboard'

Enjoy and if you find a way to allow logging in a static context let me know.

Los lenguajes listados son PL/SQL, Visual Basic y C. El mundo y Paraguay hablan más lenguajes. Porque yo trabajo normalmente con Java o Groovy yo he traducido los algoritmos en los quales lenguajes.

Quando estaba en el SET para pedir un RUC me fui al otro lado de la calle donde esta ubicado el departamento de la informatica del SET para ofrecer mis traduciones. Me daron un email para enviar mis datos que hice el 17 de Julio. Yo no sé porque todavia no he escuchado nada y no han publicado. Tal vez tienen algunos errores mis traducciones que todavía no he encontrado, en este caso pido amablemente sus correcciones.

En el caso que mis algoritmos son útil para alguien yo seria agradecido. Por favor usan el codigo libremente, pero sabiendo que viene sin ninguna garantia

Groovy

int calcDigitoVerificador(String ruc, int basemax = 11) {
	String numeroRuc = ruc.chars.collect {
			it.isDigit() ? it : (int) it
	}.join()

	int k = 2
	int total = 0
	numeroRuc.reverse().chars.each {
			k = k > basemax ? 2 : k
			int numero_aux = it - 48
			total += numero_aux * k++
	}

	int resto = total % 11
	resto > 1 ? 11 - resto : 0
}

Java

int Pa_Calcular_Dv_11_A(String p_numero, int p_basemax) {
	int v_total, v_resto, k, v_numero_aux, v_digit;
	String v_numero_al = "";

	for (int i = 0; i < p_numero.length(); i++) {
			char c = p_numero.charAt(i);
			if(Character.isDigit(c)) {
					v_numero_al += c;
			} else {
					v_numero_al += (int) c;
			}
	}

	k = 2;
	v_total = 0;

	for(int i = v_numero_al.length() - 1; i >= 0; i--) {
			k = k > p_basemax ? 2 : k;
			v_numero_aux = v_numero_al.charAt(i) - 48;
			v_total += v_numero_aux * k++;
	}

	v_resto = v_total % 11;
	v_digit = v_resto > 1 ? 11 - v_resto : 0;

	return v_digit;
}

También yo tengo un programa para probar mis funciones con el cual yo he encontrado 5 errores en los 10 archivos publicado en la pagina “Listado de Equivalencias de RUC”. Si alguien esta interesado también yo puedo publicar mis unit tests (pruebas unitarias – gracias Luis) y un reporte de los resultados.

Occasionally I also will be writing about the beautiful country I am living in or probably about a cooking recipe or a book I’m reeding or some general thoughts about live. I will tag my writings so it should be easy to filter out anything which is noise for the estimated reader which is hopefully you.

I will usually blog in English, but sometimes it could be in Spanish or in German. For the language I use categories, this is your second option to filter this blog.

So welcome to my blog and I hope you will find something interesting for you.