Async loggin with log4j 1.x

If you are reading this surely you have found out that using AsyncAppender its not clearly documented and most of your google results lead you to some log4j 2.X.

Ok, in that case this is the right post for you.

Lets take an ordinary (synchronous) file logger from Log4j 1.x ( tested with 1.2.17) and wrap it up with a 'cool' AsyncAppender. :D.

Considering that you have

import org.slf4j.Logger
...
static Logger log = LoggerFactory.getLogger("MyLogger");

You turn your internal sync appender into an async with:

static {
  AsyncAppenderBuilder.wrapAsyncAppender(log, "MyAppndrName")
}

Then use just like a regular logger

The helping class looks like this:

	import org.apache.log4j.Appender
	import org.apache.log4j.AsyncAppender
	import org.slf4j.impl.Log4jLoggerAdapter
	/**
	* Replaces the original sync appender with an async appender
	* @author arrizabalaga
	*/
	class AsyncAppenderBuilder {
	private static int DEFAULT_BUFFER_SIZE=500
	/**
	* Looks for an appender in the logger, wraps it with an async and deletes the original appender.
	* @param loggerAdapter slf4j logger adapter
	* @param nombreAppender name of the sync appender to be wrapped
	*/
	static void wrapAsyncAppender(Log4jLoggerAdapter loggerAdapter,String appenderName,int bufferSize=DEFAULT_BUFFER_SIZE) {
	//Take original appender
	org.apache.log4j.Logger log4jLogger=loggerAdapter.logger
	Appender syncAppender=log4jLogger.getAppender(appenderName)
	//Wrap it
	AsyncAppender asyncAppender=new AsyncAppender()
	asyncAppender.setBufferSize(bufferSize)
	asyncAppender.addAppender(syncAppender)
	//Add the async
	log4jLogger.addAppender(asyncAppender)
	//Remove the sync
	log4jLogger.removeAppender(syncAppender)
	}
	}

view raw AsyncAppenderBuilder hosted with ❤ by GitHub

Hope it helps!
Iván.

Grails in prod with an external log4j properties

Maybe you have tried to config your Grails app so you can:

• Use the default logging configuration inside Config.groovy for test or dev.
• Use an external log4j.properties file in production.

It's quite frustating and it is not so well documented.
After some digging I came up with a quite elegant solution:

Config.groovy:
----------------------------

import grails.util.Environment

if(Environment.current!=Environment.PRODUCTION){
  // log4j configuration
  log4j = {
    ...
  }
}

resources.groovy:
----------------------------

import grails.util.Environment

if(Environment.current==Environment.PRODUCTION){
  log4jConfigurer(org.springframework.beans.factory.config.MethodInvokingFactoryBean) {
    targetClass = "org.springframework.util.Log4jConfigurer"
    targetMethod = "initLogging"
    arguments = ["classpath:resources/log4j.properties"]
  }
} 

log4j.properties (src/resources/log4j.properties):
----------------------------

  //whatever make sense to you

Please remember NOT to forget your imports or otherwise it wont work.

Hope it helps!

PD: Grails 3.0 is about to see the light and ...well who kows!. This solution is right for Grails 2.x family.

Javascript: Haciendo herencia a través del prototype

Como en js no hay clases reales cuando se quiere obtener un funcionamiento de delegación similar hay que acudir a patrones más o menos liosos para ello.

La forma más efectiva de hacerlo (en términos de memoría) es haciendo uso de los prototypes de las funciones tal y como sigue:

	//Super class
	var Car = function(loc){
	this.loc=loc;
	};
	Car.prototype.move=function(){
	this.loc++;
	};
	//Sub class
	var Van = function (loc){
	Car.call(this.loc);
	}
	Van.prototype=Object.create(Car.prototype);
	Van.prototype.constructor=Van;
	Van.prototype.grab=function(){
	//whatever
	}
	var zed = new Car(3);
	zed.move();
	var amy=new Van(9);
	amy.move();
	amy.grab();

view raw javascript-subclassing-pattern hosted with ❤ by GitHub

PD: Sacado del curso de Udacity-Object Oriented Javascript (https://www.udacity.com/course/ud015), si puedes hazlo.

MYSQL: Updating column with a random codified value

	update `datamart`.`mytable`
	set
	mycolumn = case (FLOOR(1 + RAND() * 5))
	when 1 then 'SOME'
	when 2 then 'RANDOM'
	when 3 then 'STUFF'
	when 4 then 'RIGHT'
	when 5 then 'HERE'
	end;

view raw mysql-update-case-random hosted with ❤ by GitHub

Grails, reusing domains with a binary plugin

How should I do in order to reuse my domains?
Use your own domain's plugin, this is how.

Just create your plugin:

grails create-plugin book-remote
...{work as usual with your domains}...

Change your groupId/version and set binary as default type of packaging:

BookRemoteGrailsPlugin.groovy:

String groupId = 'com.nortia.book'
String version = '0.1'
String packaging = 'binary'

Install into local maven repo (or wherever you want to):

grails  maven install --binary

Then, you have include your plugin as a dependency for your grails app:

BuildConfig.groovy:

    dependencies {
    //Since it is  binary plugin is goes here instead of in the 'plugins' section
compile 'com.nortia.book:book-remote:0.1'
    }

That's it! :D
PD: There is no need for the plugin to be 'binary' unless you're planning to use those domains in another groovy (no grails) project (which was my case).