net.sf.log4jdbc.log.log4j2.message.SqlMessage Maven / Gradle / Ivy

Go to download
package net.sf.log4jdbc.log.log4j2.message;

import java.io.IOException;
import java.io.LineNumberReader;
import java.io.StringReader;
import java.util.StringTokenizer;
import java.util.regex.Pattern;

import net.sf.log4jdbc.Properties;

/**
 * Parent class of all Messages associated with log4jdbc log events, 
 * to perform common operations such as sql formatting.
 * 
 * Subclasses must implement the abstract buildMessage() method, 
 * that will then be called by the method getFormattedMessage() of this class, 
 * to populate the message attribute, only once. 
 * This way, messages are generated only once, and only when needed 
 * (avoid useless strings concatenations for instance).
 * 
 * @author Frederic Bastian
 * @version 1.0
 * @since 1.0
 */
public abstract class SqlMessage
{
	/**
	 * System dependent line separator. 
	 */
	protected static String nl = System.getProperty("line.separator");
	/**
	 * A boolean to define whether debugInfo should be displayed.
	 * @see #getDebugInfo()
	 */
	private boolean isDebugEnabled;
	/**
	 * A String representing the final message 
	 * built when needed using the attributes of this class.
     * @see #buildMessage()
	 */
	private String message;

	/**
	 * Default constructor.
	 */
    public SqlMessage()
    {
    	this(false);
    }
    /**
     * Constructor
     * @param isDebugEnabled A boolean used to set the isDebugEnabled attribute
     * @see #isDebugEnabled
     */
    public SqlMessage(boolean isDebugEnabled)
    {
    	this.setDebugEnabled(isDebugEnabled);
    	this.setMessage(null);
    }
    
    /**
     * Populate the message attribute.
     * All subclasses can implement this method as they want, 
     * but the outcome must be to assign a String not null 
     * to the message attribute.
     * This method is called only when this Message is actually logged, 
     * avoiding useless concatenation costs, etc.
     * 
     * @see #message
     */
    protected abstract void buildMessage();

	public String getFormattedMessage() {
		if (this.getMessage() == null) {
			this.buildMessage();
		}
		return this.getMessage();
	}

	public String getFormat() {
		return this.getFormattedMessage();
	}

	public Object[] getParameters() {
		return null;
	}
	
	/**
	 * Always return null, no messages store a Throwable in this project.
	 * @return 	always null
	 */
	public Throwable getThrowable() {
		return null;
	}
    
    /**
     * Break an SQL statement up into multiple lines in an attempt to make it
     * more readable.
     *
     * @param sql SQL to break up.
     * @return SQL broken up into multiple lines
     * @author Arthur Blake
     */
    protected String processSql(String sql)
    {
    	if (sql==null) {
    		return null;
    	}

    	if (Properties.isSqlTrim()) {
    		sql = sql.trim();
    	}

    	StringBuilder output = new StringBuilder();

    	if (Properties.getDumpSqlMaxLineLength() <= 0) {
    		output.append(sql);
    	} else {
    		// insert line breaks into sql to make it more readable
    		StringTokenizer st = new StringTokenizer(sql);
    		String token;
    		int linelength = 0;

    		while (st.hasMoreElements()) {
    			token = (String) st.nextElement();

    			output.append(token);
    			linelength += token.length();
    			output.append(" ");
    			linelength++;
    			if (linelength > Properties.getDumpSqlMaxLineLength()) {
    				output.append(nl);
    				linelength = 0;
    			}
    		}
    	}

    	if (Properties.isDumpSqlAddSemicolon()) {
    		output.append(";");
    	}

    	String stringOutput = output.toString();

    	if (Properties.isTrimExtraBlankLinesInSql()) {
    		LineNumberReader lineReader = new LineNumberReader(new StringReader(stringOutput));

    		output = new StringBuilder();

    		int contiguousBlankLines = 0;
    		int lineCount = 0;
    		try {
    			while (true) {
    				String line = lineReader.readLine();
    				if (line==null) {
    					break;
    				}
    				//add a line return only if several lines;
    				//it is the responsibility of the caller to add a final line return if needed
    				if (lineCount > 0) {
        				output.append(nl);
    				}

    				// is this line blank?
    				if (line.trim().length() == 0) {
    					contiguousBlankLines ++;
    					// skip contiguous blank lines
    					if (contiguousBlankLines > 1) {
    						continue;
    					}
    				} else {
    					contiguousBlankLines = 0;
    					output.append(line);
    				}
    				lineCount++;
    			}
    		}
    		catch (IOException e)
    		{
    			// since we are reading from a buffer, this isn't likely to happen,
    			// but if it does we just ignore it and treat it like its the end of the stream
    		}
    		stringOutput = output.toString();
    	}

    	return stringOutput;
    }
    
    /**
     * Get debugging info - the module and line number that called the logger
     * version that prints the stack trace information from the point just before
     * we got it (net.sf.log4jdbc)
     *
     * if the optional log4jdbc.debug.stack.prefix system property is defined then
     * the last call point from an application is shown in the debug
     * trace output, instead of the last direct caller into log4jdbc
     *
     * @return debugging info for whoever called into JDBC from within the application.
     * @author Arthur Blake
     */
    protected static String getDebugInfo()
    {
    	Throwable t = new Throwable();
    	t.fillInStackTrace();

    	StackTraceElement[] stackTrace = t.getStackTrace();

    	if (stackTrace != null) {
    		String className;
    		StringBuffer dump = new StringBuffer();

    		/**
    		 * The DumpFullDebugStackTrace option is useful in some situations when
    		 * we want to see the full stack trace in the debug info-  watch out
    		 * though as this will make the logs HUGE!
    		 */
    		if (Properties.isDumpFullDebugStackTrace()) {
    			boolean first=true;
    			for (int i = 0; i < stackTrace.length; i++) {
    				className = stackTrace[i].getClassName();
    				if (!className.startsWith("net.sf.log4jdbc")) {
    					if (first) {
    						first = false;
    					} else {
    						dump.append("  ");
    					}
    					dump.append("at ");
    					dump.append(stackTrace[i]);
    					dump.append(nl);
    				}
    			}
    		} else {
    			dump.append(" ");
    			int firstLog4jdbcCall = 0;
    			int lastApplicationCall = 0;

    			for (int i = 0; i < stackTrace.length; i++) {
    				className = stackTrace[i].getClassName();
    				if (className.startsWith("net.sf.log4jdbc")) {
    					firstLog4jdbcCall = i;
    					
    				} else if (Properties.isTraceFromApplication() &&
    						Pattern.matches(Properties.getDebugStackPrefix(), className)) {
    					lastApplicationCall = i;
    					break;
    				}
    			}
    			int j = lastApplicationCall;

    			if (j == 0) { // if app not found, then use whoever was the last guy that called a log4jdbc class.
    				if (stackTrace.length > 1 + firstLog4jdbcCall) {
    				    j = 1 + firstLog4jdbcCall;
    				} else {
    					j = firstLog4jdbcCall;
    				}
    			}

    			dump.append(stackTrace[j].getClassName()).append(".").append(stackTrace[j].getMethodName()).append("(").
    			append(stackTrace[j].getFileName()).append(":").append(stackTrace[j].getLineNumber()).append(")");
    		}

    		return dump.toString();
    	}
    	return null;
    }

	/**
	 * @return the isDebugEnabled
	 */
	protected boolean isDebugEnabled() {
		return this.isDebugEnabled;
	}
	/**
	 * @param isDebugEnabled the isDebugEnabled to set
	 */
	protected void setDebugEnabled(boolean isDebugEnabled) {
		this.isDebugEnabled = isDebugEnabled;
	}
	
	/**
	 * @return the message
	 */
	protected String getMessage() {
		return message;
	}
	/**
	 * @param message the message to set
	 */
	protected void setMessage(String message) {
		this.message = message;
	}
}