[유치수] [NOBTS] initial imports

git-svn-id: http://svn.bds.nhncorp.com/pe/hippo-tomcat-profiler/trunk@423 84d0f5b1-2673-498c-a247-62c4ff18d310
2026-08-15 15:55:54 +10:00 · 2012-06-19 05:51:25 +00:00
parent 20c9d38b03
commit 3be294bc76
62 changed files with 8649 additions and 0 deletions
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="lib" path="/develop/eclipse_work_j2ee/TomcatProfiler/lib/servlet-api.jar"/>
+	<classpathentry kind="lib" path="/develop/eclipse_work_j2ee/TomcatProfiler/lib/catalina.jar"/>
+	<classpathentry kind="lib" path="/develop/eclipse_work_j2ee/TomcatProfiler/lib/slf4j-api-1.5.8.jar"/>
+	<classpathentry kind="lib" path="/develop/eclipse_work_j2ee/TomcatProfiler/lib/javassist.jar"/>
+	<classpathentry kind="lib" path="/develop/eclipse_work_j2ee/TomcatProfiler/lib/libthrift-0.8.0.jar"/>
+	<classpathentry kind="lib" path="lib/catalina.jar"/>
+	<classpathentry kind="lib" path="lib/javassist.jar"/>
+	<classpathentry kind="lib" path="lib/libthrift-0.8.0.jar"/>
+	<classpathentry kind="lib" path="lib/servlet-api.jar"/>
+	<classpathentry kind="lib" path="lib/slf4j-api-1.5.8.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>TomcatProfiler</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
@@ -0,0 +1,12 @@
+#Thu Apr 19 16:46:47 KST 2012
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6
@@ -0,0 +1,17 @@
+namespace java com.profiler.dto
+
+struct JVMInfoThriftDTO {
+	1: i32		agentHashCode,
+	2: i64 		dataTime,
+	3: i32		activeThreadCount,
+	4: optional i64		gc1Count,
+	5: optional i64		gc1Time,
+	6: optional i64		gc2Count,
+	7: optional i64		gc2Time,
+	8: i64		heapUsed,
+	9: i64		heapCommitted,
+	10: i64		nonHeapUsed,
+	11:	i64		nonHeapCommitted,
+	12: optional double		processCPUTime
+	
+}
@@ -0,0 +1,21 @@
+namespace java com.profiler.dto
+struct RequestDataThriftDTO {
+	1: i32		dataType,
+	2: i64 		dataTime,
+	3: optional i32		dataHashCode,
+	4: optional string dataString,
+	5: optional string extraData1,
+	6: optional string extraData2,
+	7: optional string extraData3,
+	8: optional i32 extraInt1,
+	9: optional i32 extraInt2,
+	10: optional i32 extraInt3,
+	11: optional i64 extraLong1,
+	12: optional i64 extraLong2,
+	13: optional i64 extraLong3
+}
+struct RequestDataListThriftDTO {
+	1: i32		hostHashCode,
+	2: i32		requestHashCode,
+	3: list<RequestDataThriftDTO> requestDataList
+}
@@ -0,0 +1,22 @@
+namespace java com.profiler.dto
+struct RequestThriftDTO {
+	1: i32		hostHashCode,
+	2: i32		requestHashCode,
+	3: i32		dataType,
+	4: i64 		dataTime,
+	5: i64		threadCPUTime,
+	6: i64		threadUserTime,
+	7: optional string 	requestID,
+	8: optional string 	requestURL,
+	9: optional string 	clientIP,
+	10: optional string extraData1,
+	11: optional string extraData2,
+	12: optional string extraData3,
+	13: optional i32 extraInt1,
+	14: optional i32 extraInt2,
+	15: optional i32 extraInt3,
+	16: optional i64 extraLong1,
+	17: optional i64 extraLong2,
+	18: optional i64 extraLong3
+}
+
@@ -0,0 +1,14 @@
+TODO 
+- Make config file and read logic at TomcatProfilerConfig class
+- Performance Test on blog service's section and mylog. (Benchmark with Jennifer) 
+- install HBase server and store received data
+- Make vertx server to show HBase data. ==> Priority is very low ~~
+  
+
+DONE
+-slf4j related jar files in Thrift library is added to Tomcat's CLASS_PATH 
+==> made with out slf4j version of Thrift
+
+
+AGENT INSTALL GUIDE
+1.if service use log4j, change agent library's log4j to using log4j version if thrift is not WO version
@@ -0,0 +1,2 @@
+#ab -n 1000 -c 30 -r http://localhost:8080/test.jsp
+ab -n 5000 -c 20 -r http://10.64.84.46:8080/examples/jsp/jsptoserv/jsptoservlet.jsp
@@ -0,0 +1,13 @@
+SERVER_IP=								127.0.0.1
+AGENT_TCP_LISTEN_PORT=					9990
+SERVER_TCP_LISTEN_PORT=					9991
+REQUEST_TRANSACTION_DATA_LISTEN_PORT=	9995
+REQUEST_DATA_LISTEN_PORT=				9996
+JVM_DATA_LISTEN_PORT=					9997
+	
+#TOMCAT_LIB_PATH=/home1/irteam/apps/tomcat
+
+JVM_STAT_GAP=5000
+SERVER_CONNECT_RETRY_GAP=1000
+QUERY_COUNT_OVER_10000=false
+JDBC_PROFILE=true
@@ -0,0 +1,4 @@
+cd bin/
+jar cvfM ../HippoAgent.jar ../src/META-INF/MANIFEST.MF ./*
+cd ..
+cp ./HippoAgent.jar /work/003_Hippo/091_Lib/
@@ -0,0 +1,5 @@
+thrift -out ./src/ --gen java RequestThriftDTO.thrift 
+thrift -out ./src/ --gen java JVMInfoThriftDTO.thrift 
+thrift -out ./src/ --gen java RequestDataThriftDTO.thrift 
+cp ./src/com/profiler/dto/*ThriftDTO.java /develop/eclipse_work_j2ee/TomcatProfilerReceiver/src/com/profiler/dto/
+cp ./src/com/profiler/dto/*ThriftDTO.java /develop/eclipse_work_j2ee/TomcatProfilerDataFetch/src/com/profiler/dto/
@@ -0,0 +1,2 @@
+Premain-Class: com.profiler.TomcatProfiler
+Premain-Class: com.profiler.TomcatTracer
@@ -0,0 +1 @@
+Premain-Class: com.profiler.TomcatProfiler
@@ -0,0 +1,223 @@
+package com.profiler;
+
+import static com.profiler.config.TomcatProfilerConfig.TOMCAT_LIB_PATH;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.lang.instrument.IllegalClassFormatException;
+import java.lang.instrument.Instrumentation;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.security.ProtectionDomain;
+
+import javassist.ClassPool;
+import javassist.NotFoundException;
+
+import com.profiler.config.TomcatProfilerConfig;
+import com.profiler.modifier.db.cubrid.CubridPreparedStatementModifier;
+import com.profiler.modifier.db.cubrid.CubridResultSetModifier;
+import com.profiler.modifier.db.cubrid.CubridStatementModifier;
+import com.profiler.modifier.db.cubrid.CubridUStatementModifier;
+import com.profiler.modifier.db.dbcp.DBCPBasicDataSourceModifier;
+import com.profiler.modifier.db.dbcp.DBCPPoolModifier;
+import com.profiler.modifier.db.mssql.MSSQLConnectionModifier;
+import com.profiler.modifier.db.mssql.MSSQLPreparedStatementModifier;
+import com.profiler.modifier.db.mssql.MSSQLResultSetModifier;
+import com.profiler.modifier.db.mssql.MSSQLStatementModifier;
+import com.profiler.modifier.db.mysql.MySQLConnectionImplModifier;
+import com.profiler.modifier.db.mysql.MySQLPreparedStatementModifier;
+import com.profiler.modifier.db.mysql.MySQLResultSetModifier;
+import com.profiler.modifier.db.mysql.MySQLStatementModifier;
+import com.profiler.modifier.db.oracle.OraclePreparedStatementModifier;
+import com.profiler.modifier.db.oracle.OracleResultSetModifier;
+import com.profiler.modifier.db.oracle.OracleStatementModifier;
+import com.profiler.modifier.tomcat.EntryPointStandardHostValveModifier;
+import com.profiler.modifier.tomcat.TomcatConnectorModifier;
+import com.profiler.modifier.tomcat.TomcatStandardServiceModifier;
+public class TomcatProfiler implements ClassFileTransformer {
+	protected String agentArgString = "";
+	protected Instrumentation instrumentation;
+	ClassPool classPool ;
+	public static void premain(String agentArgs, Instrumentation inst) {
+		new TomcatProfiler(agentArgs, inst);
+	}
+
+	public TomcatProfiler(String agentArgs, Instrumentation inst) {
+		agentArgString = agentArgs;
+		instrumentation = inst;
+		instrumentation.addTransformer(this);
+		classPool= ClassPool.getDefault();
+		try {
+			classPool.appendClassPath(TOMCAT_LIB_PATH+"/lib/servlet-api.jar");
+			classPool.appendClassPath(TOMCAT_LIB_PATH+"/lib/catalina.jar");
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+	private void debug(String className) {
+//		System.out.println(className);
+//		if(className.startsWith("java/sql")) {
+//			System.out.println(className);
+//		}
+//		System.out.print(".");		
+	}
+	@Override
+	public byte[] transform(ClassLoader classLoader, String className,
+			Class<?> classBeingRedefined, ProtectionDomain protectionDomain,
+			byte[] classFileBuffer) throws IllegalClassFormatException {
+		debug(className);
+		if(className.startsWith("org/apache/catalina")) {
+			String javassistClassName = className.replace('/', '.');
+			if(javassistClassName.equals("org.apache.catalina.core.StandardHostValve")) {
+				//Add code to monitor Request and Response
+				byte[] result=EntryPointStandardHostValveModifier.modify(classPool,classLoader,javassistClassName,classFileBuffer);
+				if(result!=null) return result;
+			} else if(javassistClassName.equals("org.apache.catalina.core.StandardService")) {
+				//Add code to monitor Tomcat start and stop
+				byte[] result=TomcatStandardServiceModifier.modify(classPool,classLoader,javassistClassName,classFileBuffer);
+				if(result!=null) return result;
+			} else if(javassistClassName.equals("org.apache.catalina.connector.Connector")) {
+				//Add code to set Tomcat's port numbers
+				byte[] result=TomcatConnectorModifier.modify(classPool,classLoader,javassistClassName,classFileBuffer);
+				if(result!=null) return result;
+			}
+		}
+		//#### If JDBC_PROFILE is true, SQL data will be collected
+		if(TomcatProfilerConfig.JDBC_PROFILE) {
+				if(className.startsWith("com/mysql/jdbc")) {
+				// MySQL !!!!!!!!!!
+				String javassistClassName = className.replace('/', '.');
+				if(javassistClassName.equals("com.mysql.jdbc.ConnectionImpl")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=MySQLConnectionImplModifier.modify(classPool,classLoader,javassistClassName,classFileBuffer);
+					if(result!=null) return result;
+				} else if(javassistClassName.equals("com.mysql.jdbc.StatementImpl")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=MySQLStatementModifier.modify(classPool,classLoader,javassistClassName,classFileBuffer);
+					if(result!=null) return result;
+				} else if(javassistClassName.equals("com.mysql.jdbc.PreparedStatement")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=MySQLPreparedStatementModifier.modify(classPool,classLoader,javassistClassName,classFileBuffer);
+					if(result!=null) return result;
+				} else if(javassistClassName.equals("com.mysql.jdbc.ResultSetImpl")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=MySQLResultSetModifier.modify(classPool,classLoader,javassistClassName,classFileBuffer);
+					if(result!=null) return result;
+				}
+				
+			} else if(className.startsWith("net/sourceforge/jtds/jdbc")) {
+				// MSSQL !!!!!!!!!!
+				String javassistClassName = className.replace('/', '.');
+				if(javassistClassName.equals("net.sourceforge.jtds.jdbc.ConnectionJDBC2")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=MSSQLConnectionModifier.modify(classPool,classLoader,javassistClassName,classFileBuffer);
+					if(result!=null) return result;
+				} else if(javassistClassName.equals("net.sourceforge.jtds.jdbc.JtdsStatement")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=MSSQLStatementModifier.modify(classPool,classLoader,javassistClassName,classFileBuffer);
+					if(result!=null) return result;
+				} else if(javassistClassName.equals("net.sourceforge.jtds.jdbc.JtdsPreparedStatement")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=MSSQLPreparedStatementModifier.modify(classPool,classLoader,javassistClassName,classFileBuffer);
+					if(result!=null) return result;
+				} else if(javassistClassName.equals("net.sourceforge.jtds.jdbc.JtdsResultSet")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=MSSQLResultSetModifier.modify(classPool,classLoader,javassistClassName,classFileBuffer);
+					if(result!=null) return result;
+				} 
+				
+			} else if(className.startsWith("org/apache/commons/dbcp")) {
+				// DBCP !!!!!!!!!!
+				String javassistClassName = className.replace('/', '.');
+				if(javassistClassName.equals("org.apache.commons.dbcp.BasicDataSource")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=DBCPBasicDataSourceModifier.modify(classPool, classLoader, javassistClassName, classFileBuffer);
+					if(result!=null) return result;
+				} else if(javassistClassName.equals("org.apache.commons.dbcp.PoolingDataSource$PoolGuardConnectionWrapper")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=DBCPPoolModifier.modify(classPool, classLoader, javassistClassName, classFileBuffer);
+					if(result!=null) return result;
+				} 
+	
+			} else if(className.startsWith("cubrid/jdbc")) {
+				// CUBRID !!!!!!!!!!
+				String javassistClassName = className.replace('/', '.');
+				/*if(!javassistClassName.equals("cubrid.jdbc.driver.CUBRIDResultSet") &&
+						!javassistClassName.startsWith("cubrid.jdbc.driver.ConnectionProperties")) {
+					byte[] result=AbstractModifier.addBeforeAfterLogics(classPool, javassistClassName);
+					if(result!=null) return result;
+				}*/
+				
+				if(javassistClassName.equals("cubrid.jdbc.driver.CUBRIDStatement")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=CubridStatementModifier.modify(classPool, classLoader, javassistClassName, classFileBuffer);
+					if(result!=null) return result;
+				} else if(javassistClassName.equals("cubrid.jdbc.driver.CUBRIDPreparedStatement")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=CubridPreparedStatementModifier.modify(classPool, classLoader, javassistClassName, classFileBuffer);
+					if(result!=null) return result;
+				} else if(javassistClassName.equals("cubrid.jdbc.driver.CUBRIDResultSet")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=CubridResultSetModifier.modify(classPool, classLoader, javassistClassName, classFileBuffer);
+					if(result!=null) return result;
+				} else if(javassistClassName.equals("cubrid.jdbc.jci.UStatement")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=CubridUStatementModifier.modify(classPool, classLoader, javassistClassName, classFileBuffer);
+					if(result!=null) return result;
+				}
+			} else if(className.startsWith("oracle/jdbc")) {
+				String javassistClassName = className.replace('/', '.');
+				if(javassistClassName.equals("oracle.jdbc.driver.OraclePreparedStatement")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=OraclePreparedStatementModifier.modify(classPool, classLoader, javassistClassName, classFileBuffer);
+					if(result!=null) return result;
+				} else if(javassistClassName.equals("oracle.jdbc.driver.OracleStatement")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=OracleStatementModifier.modify(classPool, classLoader, javassistClassName, classFileBuffer);
+					if(result!=null) return result;
+				} else if(javassistClassName.equals("oracle.jdbc.driver.OracleResultSetImpl")) {
+					checkLibrary(javassistClassName,classLoader);
+					byte[] result=OracleResultSetModifier.modify(classPool, classLoader, javassistClassName, classFileBuffer);
+					if(result!=null) return result;
+				}
+			}
+		}
+//		else if(className.startsWith("java/sql")) {
+//			String javassistClassName = className.replace('/', '.');
+//			System.out.println("***** Changing "+javassistClassName);
+//			byte[] result=AbstractModifier.addBeforeAfterLogics(classPool, javassistClassName);
+//			if(result!=null) return result;
+//		}
+			
+		return null;
+	}
+
+	private void checkLibrary(String javassistClassName,ClassLoader classLoader) {
+		try {
+			classPool.get(javassistClassName);
+		} catch(NotFoundException nfe) {
+//			cnfe.printStackTrace();
+			loadClassLoaderLibraries(classLoader);
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+	}
+	private void loadClassLoaderLibraries(ClassLoader classLoader) {
+		if(classLoader instanceof URLClassLoader) {
+			URLClassLoader urlClassLoader = (URLClassLoader)classLoader;
+			URL[] urlList=urlClassLoader.getURLs();
+			for(URL tempURL:urlList) {
+				String filePath=tempURL.getFile();
+				try {
+					classPool.appendClassPath(filePath);
+//					log("Loaded "+filePath+" library.");
+				} catch(Exception e) {
+					
+				}
+			}
+		}
+	}
+	@SuppressWarnings("unused")
+	private static void log(String message) {
+		System.out.println("%%%%% "+message);
+	}
+}
@@ -0,0 +1,84 @@
+package com.profiler;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.lang.instrument.IllegalClassFormatException;
+import java.lang.instrument.Instrumentation;
+import java.security.ProtectionDomain;
+
+import javassist.ByteArrayClassPath;
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+public class TomcatTracer implements ClassFileTransformer {
+	protected String agentArgString = "";
+	protected Instrumentation instrumentation;
+	ClassPool classPool;
+	public static void premain(String agentArgs, Instrumentation inst) {
+//		TomcatProfiler profiler = new TomcatProfiler(agentArgs, inst);
+		new TomcatTracer(agentArgs, inst);
+	}
+
+	public TomcatTracer(String agentArgs, Instrumentation inst) {
+		agentArgString = agentArgs;
+		instrumentation = inst;
+		instrumentation.addTransformer(this);
+		classPool = ClassPool.getDefault();
+	}
+
+	@Override
+	public byte[] transform(ClassLoader loader, String className,
+			Class<?> classBeingRedefined, ProtectionDomain protectionDomain,
+			byte[] classfileBuffer) throws IllegalClassFormatException {
+//		System.out.println(className);
+		String javassistClassName = className.replace('/', '.');
+		if(javassistClassName.startsWith("javax.servlet.") ||
+				javassistClassName.startsWith("org.apache.tomcat") ) {
+			if(!javassistClassName.startsWith("org.apache.tomcat.util")) {
+				byte []result=changeCode(javassistClassName,classfileBuffer);
+				if(result!=null) return result;
+			}
+		} else {
+//			System.out.println("*** "+javassistClassName);
+		}
+		
+		return null;
+	}
+	private byte[] changeCode(String javassistClassName,byte[] classfileBuffer) {
+		boolean insertFlag=false;
+//		System.out.println("*** "+javassistClassName);
+		
+//		System.out.println("*** ClassPool OK");
+		classPool.insertClassPath(new ByteArrayClassPath(javassistClassName, classfileBuffer));
+//		System.out.println("*** insertClassPath OK");
+		try {
+			if(classPool==null) {
+				System.out.println("NULL");
+				classPool = ClassPool.getDefault();
+			}
+			CtClass cc = classPool.get(javassistClassName);
+//			System.out.println("%%% ClassLoader="+cc.getClass().getClassLoader());
+			CtMethod[] methodList=cc.getDeclaredMethods();
+			for(CtMethod method:methodList) {
+//				System.out.println(method.getLongName());
+				String methodName=method.getLongName();
+				if(!method.isEmpty()) {
+					System.out.println("***inserted instrument code at "+methodName);
+//					method.insertBefore("{ System.out.println(\"### "+method.getName()+"  is called. URL=\"+$1+\" \");}");
+					method.insertBefore("{ System.out.println(\"--- "+methodName+"  is called. \");}");
+					insertFlag=true;
+				}
+			}
+			if(insertFlag) {
+				byte[] newClassfileBuffer = cc.toBytecode();
+				System.out.println("@@@"+javassistClassName+"class's new Buffer generated !!!");
+				
+				return newClassfileBuffer;
+			}
+		} catch(Exception e) {
+//			e.printStackTrace();
+			System.err.println("!!!!! "+e.getMessage());
+		}
+		return null;
+	}
+}
@@ -0,0 +1,96 @@
+package com.profiler.config;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.util.Properties;
+
+public class TomcatProfilerConfig {
+	public static String SERVER_IP="127.0.0.1";
+//	public static String SERVER_IP="10.25.131.94";
+	public static String TOMCAT_LIB_PATH="/home1/irteam/apps/tomcat";
+	static {
+		String catalinaHome=System.getProperty("catalina.home");
+		if(catalinaHome!=null) {
+			TOMCAT_LIB_PATH=catalinaHome;
+		}
+	}
+
+	
+	public static int AGENT_TCP_LISTEN_PORT=9990;
+	public static int SERVER_TCP_LISTEN_PORT=9991;
+	public static int REQUEST_TRANSACTION_DATA_LISTEN_PORT=9995;
+	public static int REQUEST_DATA_LISTEN_PORT=9996;
+	public static int JVM_DATA_LISTEN_PORT=9997;
+	
+	
+	public static long JVM_STAT_GAP=5000;
+	public static long SERVER_CONNECT_RETRY_GAP=1000;
+	
+	/**
+	 * If sql query count is over 10000 it consumes Memory.
+	 * So sqlHashSet uses CopyOnWriteArraySet. 
+	 * It is slow, but it is stable. 
+	 * Default set is false and it uses HashSet.
+	 */
+	public static boolean QUERY_COUNT_OVER_10000=false;
+	public static boolean JDBC_PROFILE=true;
+//	public static boolean URL_COUNT_OVER_10000=false;
+	
+//	public static String MSSQL_ENCODING="MS949";
+	
+	static {
+		readConfigFile();
+	}
+	public static void readConfigFile() {
+		String hippoConfigFileName=System.getProperty("hippo.config");
+		if(hippoConfigFileName!=null) {
+//			System.out.println("%%%%%%%%%%%%%%%%%%%%% hippo.config File="+hippoConfigFileName);
+			Properties prop=new Properties();
+			try {
+				FileReader reader=new FileReader(hippoConfigFileName);
+				prop.load(reader);
+				reader.close();
+				setPropertyValues(prop);
+			} catch(FileNotFoundException fnfe) {
+				System.out.println("##### "+hippoConfigFileName+" file is not exists. Please check configuration.");
+			} catch(Exception e) {
+				e.printStackTrace();
+			}
+		} else {
+			System.out.println("##### hippo.config property is not set. Using default values #####");
+		}
+	}
+	private static void setPropertyValues(Properties prop) {
+		Object temp=null;
+		//##### set String values #####
+		if((temp=prop.get("SERVER_IP"))!=null) 
+			SERVER_IP=temp.toString();
+		if((temp=prop.get("TOMCAT_LIB_PATH"))!=null)
+			TOMCAT_LIB_PATH=temp.toString();
+
+		//##### set int values #####
+		if((temp=prop.get("AGENT_TCP_LISTEN_PORT"))!=null) 
+			AGENT_TCP_LISTEN_PORT=Integer.parseInt(temp.toString());
+		if((temp=prop.get("SERVER_TCP_LISTEN_PORT"))!=null) 
+			SERVER_TCP_LISTEN_PORT=Integer.parseInt(temp.toString());
+		if((temp=prop.get("REQUEST_TRANSACTION_DATA_LISTEN_PORT"))!=null) 
+			REQUEST_TRANSACTION_DATA_LISTEN_PORT=Integer.parseInt(temp.toString());
+		if((temp=prop.get("REQUEST_DATA_LISTEN_PORT"))!=null) 
+			REQUEST_DATA_LISTEN_PORT=Integer.parseInt(temp.toString());
+		if((temp=prop.get("JVM_DATA_LISTEN_PORT"))!=null) 
+			JVM_DATA_LISTEN_PORT=Integer.parseInt(temp.toString());
+		
+		//##### set long values #####
+		if((temp=prop.get("JVM_STAT_GAP"))!=null) 
+			JVM_STAT_GAP=Long.parseLong(temp.toString());
+		if((temp=prop.get("SERVER_CONNECT_RETRY_GAP"))!=null) 
+			SERVER_CONNECT_RETRY_GAP=Long.parseLong(temp.toString());
+		
+		//##### set boolean values #####
+		if((temp=prop.get("QUERY_COUNT_OVER_10000"))!=null) 
+			QUERY_COUNT_OVER_10000=Boolean.parseBoolean(temp.toString());
+		if((temp=prop.get("JDBC_PROFILE"))!=null) 
+			JDBC_PROFILE=Boolean.parseBoolean(temp.toString());
+		System.out.println("##### Hippo Config Loaded successfully. #####");
+	}
+}
@@ -0,0 +1,42 @@
+package com.profiler.config;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+
+public class TomcatProfilerConstant {
+	public final static DateFormat DATE_FORMAT_YMD_HMS=new SimpleDateFormat("yyyy_MM_dd_HH_mm_ss");
+	public final static DateFormat DATE_FORMAT_HMS_MS=new SimpleDateFormat("HH:mm:ss,SSS");
+	public static final long DATA_FETCH_INTERVAL=2000;
+//	public static final String ID_ACTIVE_THREAD_COUNT="ATC";
+//	public static final String ID_HOST_INFO="HI";
+//	public static final String ID_GC_STAT="GS";
+//	public static final String ID_HEAP_MEMORY_USAGE_STAT="HMU";
+//	public static final String ID_NON_HEAP_MEMORY_USAGE_STAT="NHMU";
+	
+	
+	public static final int DATA_TYPE_REQUEST=1;
+	public static final int DATA_TYPE_RESPONSE=2;
+	public static final int DATA_TYPE_UNCAUGHT_EXCEPTION=11;
+	
+//	public static final int DATA_TYPE_HOST_INFO=1000;
+//	public static final int DATA_TYPE_ACTIVE_THREAD_COUNT=1100;
+//	public static final int DATA_TYPE_GC_STAT=1500;
+//	public static final int DATA_TYPE_HEAP_MEMORY_STAT=1510;
+//	public static final int DATA_TYPE_NON_HEAP_MEMORY_STAT=1520;
+	
+	public static final String CLASS_NAME_REQUEST_TRACER="com.profiler.trace.RequestTransactionTracer";
+	public static final String CLASS_NAME_REQUEST_THRIFT_DTO="com.profiler.dto.RequestThriftDTO";
+	public static final String CLASS_NAME_REQUEST_DATA_TRACER="com.profiler.trace.RequestDataTracer";
+	public static final String CLASS_NAME_AGENT_STATE_MANAGER="com.profiler.thread.AgentStateManager";
+	
+	public static final int REQ_DATA_TYPE_DB_GET_CONNECTION=1;
+	public static final int REQ_DATA_TYPE_DB_CREATE_STATEMENT=11;
+	public static final int REQ_DATA_TYPE_DB_GET_PREPARED_STATEMENT=12;
+	public static final int REQ_DATA_TYPE_DB_QUERY=21;
+	public static final int REQ_DATA_TYPE_DB_EXECUTE_QUERY=31;
+	public static final int REQ_DATA_TYPE_DB_EXECUTE_UPDATE=32;
+	public static final int REQ_DATA_TYPE_DB_FETCH=41;
+	public static final int REQ_DATA_TYPE_DB_RESULTSET_CLOSE=42;
+	public static final int REQ_DATA_TYPE_DB_PREPARED_STATEMENT_PARAM=51;
+	public static final int REQ_DATA_TYPE_DB_CLOSE_CONNECTION=99;
+}
@@ -0,0 +1,66 @@
+package com.profiler.dto;
+
+import java.io.Serializable;
+
+import com.profiler.config.TomcatProfilerConfig;
+
+public class AgentInfoDTO implements Serializable {
+	private static final long serialVersionUID = 1465266151876398515L;
+	public AgentInfoDTO() {
+		hostHashCode=staticHostHashCode;
+		hostIP=staticHostIP;
+		portNumbers=staticPortNumber;
+		agentTCPPortNumber=TomcatProfilerConfig.AGENT_TCP_LISTEN_PORT;
+		timestamp=System.currentTimeMillis();
+	}
+	public transient static final StringBuffer portNumberBuffer=new StringBuffer();
+	// static variable is only used in the agent.
+	public static int staticHostHashCode;
+	public static String staticHostIP,staticPortNumber;
+	// instance variable is commonly used.
+	private String hostIP,portNumbers;
+	private int hostHashCode,agentTCPPortNumber;
+	private boolean isAlive=true;
+	private long timestamp;
+	public void setIsDead() {
+		isAlive=false;
+	}
+	public static String getPortNumberString() {
+		staticPortNumber=portNumberBuffer.toString();
+		staticPortNumber.trim();
+		return staticPortNumber;
+	}
+	public String toString() {
+		return hostHashCode+" "+hostIP+" "+portNumbers+" "+agentTCPPortNumber+" isAlive="+isAlive;
+	}
+	public String getHostIP() {
+		return hostIP;
+	}
+	public void setHostIP(String hostIP) {
+		this.hostIP = hostIP;
+	}
+	public int getHostHashCode() {
+		return hostHashCode;
+	}
+	public void setHostHashCode(int hostHashCode) {
+		this.hostHashCode = hostHashCode;
+	}
+	public String getPortNumbers() {
+		return portNumbers;
+	}
+	public void setPortNumbers(String portNumber) {
+		this.portNumbers = portNumber;
+	}
+	public int getAgentTCPPortNumber() {
+		return agentTCPPortNumber;
+	}
+	public void setAgentTCPPortNumber(int agentTCPPortNumber) {
+		this.agentTCPPortNumber = agentTCPPortNumber;
+	}
+	public long getTimestamp() {
+		return timestamp;
+	}
+	public boolean isAlive() {
+		return isAlive;
+	}
+}
@@ -0,0 +1,629 @@
+/**
+ * Autogenerated by Thrift Compiler (0.8.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package com.profiler.dto;
+
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class RequestDataListThriftDTO implements org.apache.thrift.TBase<RequestDataListThriftDTO, RequestDataListThriftDTO._Fields>, java.io.Serializable, Cloneable {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RequestDataListThriftDTO");
+
+  private static final org.apache.thrift.protocol.TField HOST_HASH_CODE_FIELD_DESC = new org.apache.thrift.protocol.TField("hostHashCode", org.apache.thrift.protocol.TType.I32, (short)1);
+  private static final org.apache.thrift.protocol.TField REQUEST_HASH_CODE_FIELD_DESC = new org.apache.thrift.protocol.TField("requestHashCode", org.apache.thrift.protocol.TType.I32, (short)2);
+  private static final org.apache.thrift.protocol.TField REQUEST_DATA_LIST_FIELD_DESC = new org.apache.thrift.protocol.TField("requestDataList", org.apache.thrift.protocol.TType.LIST, (short)3);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new RequestDataListThriftDTOStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new RequestDataListThriftDTOTupleSchemeFactory());
+  }
+
+  public int hostHashCode; // required
+  public int requestHashCode; // required
+  public List<RequestDataThriftDTO> requestDataList; // required
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    HOST_HASH_CODE((short)1, "hostHashCode"),
+    REQUEST_HASH_CODE((short)2, "requestHashCode"),
+    REQUEST_DATA_LIST((short)3, "requestDataList");
+
+    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+    static {
+      for (_Fields field : EnumSet.allOf(_Fields.class)) {
+        byName.put(field.getFieldName(), field);
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, or null if its not found.
+     */
+    public static _Fields findByThriftId(int fieldId) {
+      switch(fieldId) {
+        case 1: // HOST_HASH_CODE
+          return HOST_HASH_CODE;
+        case 2: // REQUEST_HASH_CODE
+          return REQUEST_HASH_CODE;
+        case 3: // REQUEST_DATA_LIST
+          return REQUEST_DATA_LIST;
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, throwing an exception
+     * if it is not found.
+     */
+    public static _Fields findByThriftIdOrThrow(int fieldId) {
+      _Fields fields = findByThriftId(fieldId);
+      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+      return fields;
+    }
+
+    /**
+     * Find the _Fields constant that matches name, or null if its not found.
+     */
+    public static _Fields findByName(String name) {
+      return byName.get(name);
+    }
+
+    private final short _thriftId;
+    private final String _fieldName;
+
+    _Fields(short thriftId, String fieldName) {
+      _thriftId = thriftId;
+      _fieldName = fieldName;
+    }
+
+    public short getThriftFieldId() {
+      return _thriftId;
+    }
+
+    public String getFieldName() {
+      return _fieldName;
+    }
+  }
+
+  // isset id assignments
+  private static final int __HOSTHASHCODE_ISSET_ID = 0;
+  private static final int __REQUESTHASHCODE_ISSET_ID = 1;
+  private BitSet __isset_bit_vector = new BitSet(2);
+  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.HOST_HASH_CODE, new org.apache.thrift.meta_data.FieldMetaData("hostHashCode", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    tmpMap.put(_Fields.REQUEST_HASH_CODE, new org.apache.thrift.meta_data.FieldMetaData("requestHashCode", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    tmpMap.put(_Fields.REQUEST_DATA_LIST, new org.apache.thrift.meta_data.FieldMetaData("requestDataList", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
+            new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, RequestDataThriftDTO.class))));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(RequestDataListThriftDTO.class, metaDataMap);
+  }
+
+  public RequestDataListThriftDTO() {
+  }
+
+  public RequestDataListThriftDTO(
+    int hostHashCode,
+    int requestHashCode,
+    List<RequestDataThriftDTO> requestDataList)
+  {
+    this();
+    this.hostHashCode = hostHashCode;
+    setHostHashCodeIsSet(true);
+    this.requestHashCode = requestHashCode;
+    setRequestHashCodeIsSet(true);
+    this.requestDataList = requestDataList;
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public RequestDataListThriftDTO(RequestDataListThriftDTO other) {
+    __isset_bit_vector.clear();
+    __isset_bit_vector.or(other.__isset_bit_vector);
+    this.hostHashCode = other.hostHashCode;
+    this.requestHashCode = other.requestHashCode;
+    if (other.isSetRequestDataList()) {
+      List<RequestDataThriftDTO> __this__requestDataList = new ArrayList<RequestDataThriftDTO>();
+      for (RequestDataThriftDTO other_element : other.requestDataList) {
+        __this__requestDataList.add(new RequestDataThriftDTO(other_element));
+      }
+      this.requestDataList = __this__requestDataList;
+    }
+  }
+
+  public RequestDataListThriftDTO deepCopy() {
+    return new RequestDataListThriftDTO(this);
+  }
+
+  @Override
+  public void clear() {
+    setHostHashCodeIsSet(false);
+    this.hostHashCode = 0;
+    setRequestHashCodeIsSet(false);
+    this.requestHashCode = 0;
+    this.requestDataList = null;
+  }
+
+  public int getHostHashCode() {
+    return this.hostHashCode;
+  }
+
+  public RequestDataListThriftDTO setHostHashCode(int hostHashCode) {
+    this.hostHashCode = hostHashCode;
+    setHostHashCodeIsSet(true);
+    return this;
+  }
+
+  public void unsetHostHashCode() {
+    __isset_bit_vector.clear(__HOSTHASHCODE_ISSET_ID);
+  }
+
+  /** Returns true if field hostHashCode is set (has been assigned a value) and false otherwise */
+  public boolean isSetHostHashCode() {
+    return __isset_bit_vector.get(__HOSTHASHCODE_ISSET_ID);
+  }
+
+  public void setHostHashCodeIsSet(boolean value) {
+    __isset_bit_vector.set(__HOSTHASHCODE_ISSET_ID, value);
+  }
+
+  public int getRequestHashCode() {
+    return this.requestHashCode;
+  }
+
+  public RequestDataListThriftDTO setRequestHashCode(int requestHashCode) {
+    this.requestHashCode = requestHashCode;
+    setRequestHashCodeIsSet(true);
+    return this;
+  }
+
+  public void unsetRequestHashCode() {
+    __isset_bit_vector.clear(__REQUESTHASHCODE_ISSET_ID);
+  }
+
+  /** Returns true if field requestHashCode is set (has been assigned a value) and false otherwise */
+  public boolean isSetRequestHashCode() {
+    return __isset_bit_vector.get(__REQUESTHASHCODE_ISSET_ID);
+  }
+
+  public void setRequestHashCodeIsSet(boolean value) {
+    __isset_bit_vector.set(__REQUESTHASHCODE_ISSET_ID, value);
+  }
+
+  public int getRequestDataListSize() {
+    return (this.requestDataList == null) ? 0 : this.requestDataList.size();
+  }
+
+  public java.util.Iterator<RequestDataThriftDTO> getRequestDataListIterator() {
+    return (this.requestDataList == null) ? null : this.requestDataList.iterator();
+  }
+
+  public void addToRequestDataList(RequestDataThriftDTO elem) {
+    if (this.requestDataList == null) {
+      this.requestDataList = new ArrayList<RequestDataThriftDTO>();
+    }
+    this.requestDataList.add(elem);
+  }
+
+  public List<RequestDataThriftDTO> getRequestDataList() {
+    return this.requestDataList;
+  }
+
+  public RequestDataListThriftDTO setRequestDataList(List<RequestDataThriftDTO> requestDataList) {
+    this.requestDataList = requestDataList;
+    return this;
+  }
+
+  public void unsetRequestDataList() {
+    this.requestDataList = null;
+  }
+
+  /** Returns true if field requestDataList is set (has been assigned a value) and false otherwise */
+  public boolean isSetRequestDataList() {
+    return this.requestDataList != null;
+  }
+
+  public void setRequestDataListIsSet(boolean value) {
+    if (!value) {
+      this.requestDataList = null;
+    }
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case HOST_HASH_CODE:
+      if (value == null) {
+        unsetHostHashCode();
+      } else {
+        setHostHashCode((Integer)value);
+      }
+      break;
+
+    case REQUEST_HASH_CODE:
+      if (value == null) {
+        unsetRequestHashCode();
+      } else {
+        setRequestHashCode((Integer)value);
+      }
+      break;
+
+    case REQUEST_DATA_LIST:
+      if (value == null) {
+        unsetRequestDataList();
+      } else {
+        setRequestDataList((List<RequestDataThriftDTO>)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case HOST_HASH_CODE:
+      return Integer.valueOf(getHostHashCode());
+
+    case REQUEST_HASH_CODE:
+      return Integer.valueOf(getRequestHashCode());
+
+    case REQUEST_DATA_LIST:
+      return getRequestDataList();
+
+    }
+    throw new IllegalStateException();
+  }
+
+  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+  public boolean isSet(_Fields field) {
+    if (field == null) {
+      throw new IllegalArgumentException();
+    }
+
+    switch (field) {
+    case HOST_HASH_CODE:
+      return isSetHostHashCode();
+    case REQUEST_HASH_CODE:
+      return isSetRequestHashCode();
+    case REQUEST_DATA_LIST:
+      return isSetRequestDataList();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof RequestDataListThriftDTO)
+      return this.equals((RequestDataListThriftDTO)that);
+    return false;
+  }
+
+  public boolean equals(RequestDataListThriftDTO that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_hostHashCode = true;
+    boolean that_present_hostHashCode = true;
+    if (this_present_hostHashCode || that_present_hostHashCode) {
+      if (!(this_present_hostHashCode && that_present_hostHashCode))
+        return false;
+      if (this.hostHashCode != that.hostHashCode)
+        return false;
+    }
+
+    boolean this_present_requestHashCode = true;
+    boolean that_present_requestHashCode = true;
+    if (this_present_requestHashCode || that_present_requestHashCode) {
+      if (!(this_present_requestHashCode && that_present_requestHashCode))
+        return false;
+      if (this.requestHashCode != that.requestHashCode)
+        return false;
+    }
+
+    boolean this_present_requestDataList = true && this.isSetRequestDataList();
+    boolean that_present_requestDataList = true && that.isSetRequestDataList();
+    if (this_present_requestDataList || that_present_requestDataList) {
+      if (!(this_present_requestDataList && that_present_requestDataList))
+        return false;
+      if (!this.requestDataList.equals(that.requestDataList))
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    return 0;
+  }
+
+  public int compareTo(RequestDataListThriftDTO other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+    RequestDataListThriftDTO typedOther = (RequestDataListThriftDTO)other;
+
+    lastComparison = Boolean.valueOf(isSetHostHashCode()).compareTo(typedOther.isSetHostHashCode());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetHostHashCode()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.hostHashCode, typedOther.hostHashCode);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetRequestHashCode()).compareTo(typedOther.isSetRequestHashCode());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetRequestHashCode()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.requestHashCode, typedOther.requestHashCode);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetRequestDataList()).compareTo(typedOther.isSetRequestDataList());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetRequestDataList()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.requestDataList, typedOther.requestDataList);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("RequestDataListThriftDTO(");
+    boolean first = true;
+
+    sb.append("hostHashCode:");
+    sb.append(this.hostHashCode);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("requestHashCode:");
+    sb.append(this.requestHashCode);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("requestDataList:");
+    if (this.requestDataList == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.requestDataList);
+    }
+    first = false;
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+    try {
+      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+      __isset_bit_vector = new BitSet(1);
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private static class RequestDataListThriftDTOStandardSchemeFactory implements SchemeFactory {
+    public RequestDataListThriftDTOStandardScheme getScheme() {
+      return new RequestDataListThriftDTOStandardScheme();
+    }
+  }
+
+  private static class RequestDataListThriftDTOStandardScheme extends StandardScheme<RequestDataListThriftDTO> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, RequestDataListThriftDTO struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField schemeField;
+      iprot.readStructBegin();
+      while (true)
+      {
+        schemeField = iprot.readFieldBegin();
+        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
+          break;
+        }
+        switch (schemeField.id) {
+          case 1: // HOST_HASH_CODE
+            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+              struct.hostHashCode = iprot.readI32();
+              struct.setHostHashCodeIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 2: // REQUEST_HASH_CODE
+            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+              struct.requestHashCode = iprot.readI32();
+              struct.setRequestHashCodeIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 3: // REQUEST_DATA_LIST
+            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list0 = iprot.readListBegin();
+                struct.requestDataList = new ArrayList<RequestDataThriftDTO>(_list0.size);
+                for (int _i1 = 0; _i1 < _list0.size; ++_i1)
+                {
+                  RequestDataThriftDTO _elem2; // required
+                  _elem2 = new RequestDataThriftDTO();
+                  _elem2.read(iprot);
+                  struct.requestDataList.add(_elem2);
+                }
+                iprot.readListEnd();
+              }
+              struct.setRequestDataListIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+
+      // check for required fields of primitive type, which can't be checked in the validate method
+      struct.validate();
+    }
+
+    public void write(org.apache.thrift.protocol.TProtocol oprot, RequestDataListThriftDTO struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(HOST_HASH_CODE_FIELD_DESC);
+      oprot.writeI32(struct.hostHashCode);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(REQUEST_HASH_CODE_FIELD_DESC);
+      oprot.writeI32(struct.requestHashCode);
+      oprot.writeFieldEnd();
+      if (struct.requestDataList != null) {
+        oprot.writeFieldBegin(REQUEST_DATA_LIST_FIELD_DESC);
+        {
+          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.requestDataList.size()));
+          for (RequestDataThriftDTO _iter3 : struct.requestDataList)
+          {
+            _iter3.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class RequestDataListThriftDTOTupleSchemeFactory implements SchemeFactory {
+    public RequestDataListThriftDTOTupleScheme getScheme() {
+      return new RequestDataListThriftDTOTupleScheme();
+    }
+  }
+
+  private static class RequestDataListThriftDTOTupleScheme extends TupleScheme<RequestDataListThriftDTO> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, RequestDataListThriftDTO struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      BitSet optionals = new BitSet();
+      if (struct.isSetHostHashCode()) {
+        optionals.set(0);
+      }
+      if (struct.isSetRequestHashCode()) {
+        optionals.set(1);
+      }
+      if (struct.isSetRequestDataList()) {
+        optionals.set(2);
+      }
+      oprot.writeBitSet(optionals, 3);
+      if (struct.isSetHostHashCode()) {
+        oprot.writeI32(struct.hostHashCode);
+      }
+      if (struct.isSetRequestHashCode()) {
+        oprot.writeI32(struct.requestHashCode);
+      }
+      if (struct.isSetRequestDataList()) {
+        {
+          oprot.writeI32(struct.requestDataList.size());
+          for (RequestDataThriftDTO _iter4 : struct.requestDataList)
+          {
+            _iter4.write(oprot);
+          }
+        }
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, RequestDataListThriftDTO struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      BitSet incoming = iprot.readBitSet(3);
+      if (incoming.get(0)) {
+        struct.hostHashCode = iprot.readI32();
+        struct.setHostHashCodeIsSet(true);
+      }
+      if (incoming.get(1)) {
+        struct.requestHashCode = iprot.readI32();
+        struct.setRequestHashCodeIsSet(true);
+      }
+      if (incoming.get(2)) {
+        {
+          org.apache.thrift.protocol.TList _list5 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.requestDataList = new ArrayList<RequestDataThriftDTO>(_list5.size);
+          for (int _i6 = 0; _i6 < _list5.size; ++_i6)
+          {
+            RequestDataThriftDTO _elem7; // required
+            _elem7 = new RequestDataThriftDTO();
+            _elem7.read(iprot);
+            struct.requestDataList.add(_elem7);
+          }
+        }
+        struct.setRequestDataListIsSet(true);
+      }
+    }
+  }
+
+}
+
@@ -0,0 +1,106 @@
+package com.profiler.modifier;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtMethod;
+
+public abstract class AbstractModifier {
+	public static void printClassInfo(String className) {
+		log("Printing Class Info of ["+className+"]");
+		try {
+			ClassPool pool=ClassPool.getDefault();
+//			pool.insertClassPath(new ClassClassPath(currentClass));
+			log("try");
+			String javaassistClassName = className.replace('/', '.');
+			log("replace");
+			CtClass cc=pool.get(javaassistClassName);
+			log("ClassName:"+javaassistClassName);
+			CtConstructor[] constructorList=cc.getConstructors();
+			for(CtConstructor cons:constructorList) {
+				try {
+					String signature=cons.getSignature();
+					System.out.println("Constructor signature:"+signature);
+				} catch(Exception e) {
+					e.printStackTrace();
+				}
+			}
+			CtMethod[] methodList=cc.getDeclaredMethods();
+			for(CtMethod tempMethod:methodList) {
+				try {
+					String methodName=tempMethod.getLongName();
+					log("MethodName:"+methodName);
+					CtClass[] params=tempMethod.getParameterTypes();
+					if(params.length!=0) {
+						int paramsLength=params.length;
+						for(int loop=paramsLength-1;loop>0;loop--) {
+							log("Param"+loop+":"+params[loop].getName());
+						}
+					} else {
+						log("    No params");
+					}
+					log("ReturnType="+tempMethod.getReturnType().getName());
+				} catch(Exception methodException) {
+					log("Exception : "+methodException.getMessage());
+				}
+			}
+		} catch(Exception e) {
+			log(e.getMessage());
+			e.printStackTrace();
+		} 
+	}
+
+	public static byte[] addBeforeAfterLogics(ClassPool classPool,String javassistClassName) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			CtMethod[] methods=cc.getDeclaredMethods();
+			for(CtMethod method:methods) {
+				if(!method.isEmpty() ) {
+					String methodName=method.getName();
+					CtClass[] params=method.getParameterTypes();
+					StringBuilder sb=new StringBuilder();
+					if(params.length!=0) {
+						int paramsLength=params.length;
+						for(int loop=paramsLength-1;loop>0;loop--) {
+							sb.append(params[loop].getName()).append(",");
+						}
+//						sb.substring(0, sb.length()-2);
+					}
+					method.insertBefore("{System.out.println(\"*****"+javassistClassName+"."+methodName+"("+sb+") is started.\");}");
+					method.insertAfter("{System.out.println(\"*****"+javassistClassName+"."+methodName+"("+sb+") is finished.\");}");
+				} else {
+					log(method.getLongName()+" is empty !!!!!");
+				}
+			}
+			CtConstructor[] constructors=cc.getConstructors();
+			for(CtConstructor constructor:constructors) {
+				if(!constructor.isEmpty()) {
+					CtClass[] params=constructor.getParameterTypes();
+					StringBuilder sb=new StringBuilder();
+					if(params.length!=0) {
+						int paramsLength=params.length;
+						for(int loop=paramsLength-1;loop>0;loop--) {
+							sb.append(params[loop].getName()).append(",");
+						}
+//						sb.substring(0, sb.length()-2);
+					}
+					constructor.insertBefore("{System.out.println(\"*****"+javassistClassName+" Constructor:Param=("+sb+") is started.\");}");
+					constructor.insertAfter("{System.out.println(\"*****"+javassistClassName+" Constructor:Param=("+sb+") is finished.\");}");
+				} else {
+					log(constructor.getLongName()+" is empty !!!!!");
+				}
+			}
+			return cc.toBytecode();
+		} catch(Exception e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+	public static void log(String message) {
+		System.out.println("[AbstractModifier] "+message);
+	}
+	public static void printClassConvertComplete(String javassistClassName) {
+		log("@@@ "+javassistClassName+" class is converted !!!");
+		
+	}
+}
@@ -0,0 +1,76 @@
+package com.profiler.modifier.db.cubrid;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class CubridPreparedStatementModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("CubridPreparedStatementModifier modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateExecuteQueryMethod(classPool,cc);
+			updateConstructor(classPool,cc);
+
+			byte[] newClassfileBuffer = cc.toBytecode();
+//			cc.writeFile();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	private static void updateConstructor(ClassPool classPool,CtClass cc) throws Exception {
+		CtConstructor []constructorList=cc.getConstructors();
+		for(CtConstructor constructor:constructorList) {
+			CtClass params[]=constructor.getParameterTypes();
+			log("*** Constructor param length="+params.length);
+			if(params.length>2 ) {
+				constructor.insertBefore(getConstructorBeforeInsertCode());
+			}
+		}
+	}
+	private static String getConstructorBeforeInsertCode() {
+		log("*** Changing Constructor ");
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----CUBRIDPreparedStatement constructor is called\");");
+		sb.append("if($2 instanceof cubrid.jdbc.jci.UStatement) { ");
+//		sb.append("System.out.println(\"-----Query=[\"+$2.getQuery()+\"]\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putSqlQuery("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_QUERY+",$2.getQuery());");
+		sb.append("}}");
+		return sb.toString();
+	}
+	private static void updateExecuteQueryMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod=cc.getDeclaredMethod("execute", null);
+		log("*** Changing execute() method ");
+//		serviceMethod.insertBefore(getExecuteQueryMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getExecuteQueryMethodAfterInsertCode());
+	}
+	@SuppressWarnings("unused")
+	private static String getExecuteQueryMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----CUBRIDPreparedStatement.execute() method is called\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	private static String getExecuteQueryMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----CUBRIDPreparedStatement.execute() method is ended\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".put("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_EXECUTE_QUERY+");");
+		sb.append("}");
+		return sb.toString();
+		
+	}
+}
@@ -0,0 +1,58 @@
+package com.profiler.modifier.db.cubrid;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class CubridResultSetModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("CubridResultSetModifier modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateNextMethod(classPool,cc);
+			updateCloseMethod(classPool,cc);
+			byte[] newClassfileBuffer = cc.toBytecode();
+//			cc.writeFile();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	private static void updateNextMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod1=cc.getDeclaredMethod("next", null);
+		log("*** Changing next() method ");
+		serviceMethod1.insertBefore(getNextMethodBeforeInsertCode());
+	}
+	private static String getNextMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"PreparedStatement.setInternal(int,String) method is called\");");
+//		sb.append("System.out.println(\"-----Position=\"+$1+\" Value=\"+$2);");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".updateFetchCount();");
+		sb.append("}");
+		return sb.toString();
+	}
+	private static void updateCloseMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod1=cc.getDeclaredMethod("close", null);
+		log("*** Changing close() method ");
+		serviceMethod1.insertBefore(getCloseMethodBeforeInsertCode());
+	}
+	private static String getCloseMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"PreparedStatement.setInternal(int,String) method is called\");");
+//		sb.append("System.out.println(\"-----Position=\"+$1+\" Value=\"+$2);");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".addResultSetData();");
+		sb.append("}");
+		return sb.toString();
+	}
+}
@@ -0,0 +1,59 @@
+package com.profiler.modifier.db.cubrid;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class CubridStatementModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("CubridStatementModifier modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateExecuteQueryMethod(classPool,cc);
+			byte[] newClassfileBuffer = cc.toBytecode();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	private static void updateExecuteQueryMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtClass[] params=new CtClass[1];
+		params[0]=classPool.getCtClass("java.lang.String");
+		CtMethod serviceMethod=cc.getDeclaredMethod("executeQuery", params);
+//		CtMethod serviceMethod=cc.getDeclaredMethod("executeQuery", null);
+		log("*** Changing executeQuery method ");
+//		serviceMethod.insertBefore(getExecuteQueryMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getExecuteQueryMethodAfterInsertCode());
+		
+		
+	}
+	@SuppressWarnings("unused")
+	private static String getExecuteQueryMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----CUBRIDStatement.executeQuery() method is called\");");
+//		sb.append("System.out.println(\"-----CUBRIDStatement.executeQuery(String) method is called\");");
+//		sb.append("System.out.println(\"-----Query=[\"+com.profiler.util.QueryStringUtil.removeCarriageReturn($1)+\"]\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	private static String getExecuteQueryMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----CUBRIDStatement.executeQuery(String) method is ended\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putSqlQuery("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_QUERY+",$1);");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".put("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_EXECUTE_QUERY+");");
+		sb.append("}");
+		return sb.toString();
+		
+	}
+}
@@ -0,0 +1,49 @@
+package com.profiler.modifier.db.cubrid;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class CubridUStatementModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("CubridUStatementModifier modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateBindValueMethod(classPool,cc);
+
+			byte[] newClassfileBuffer = cc.toBytecode();
+//			cc.writeFile();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	private static void updateBindValueMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtClass[] params1=new CtClass[3];
+		params1[0]=classPool.getCtClass("int");
+		params1[1]=classPool.getCtClass("byte");
+		params1[2]=classPool.getCtClass("java.lang.Object");
+		CtMethod serviceMethod1=cc.getDeclaredMethod("bindValue", params1);
+		log("*** Changing bindValue(int,byte,String) method ");
+		serviceMethod1.insertBefore(getBindValueMethodBeforeInsertCode());
+	}
+	private static String getBindValueMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"UStatement.setInternal(int,String) method is called\");");
+//		sb.append("System.out.println(\"-----Position=\"+$1+\" Value=\"+$3);");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putSqlParam($1,$3);");
+		sb.append("}");
+		return sb.toString();
+	}
+	
+}
@@ -0,0 +1,56 @@
+package com.profiler.modifier.db.dbcp;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class DBCPBasicDataSourceModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("DBCPBasicDataSourceModifier modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateGetConnectionMethod(classPool,cc);
+//			updateCloseMethod(classPool,cc);
+			byte[] newClassfileBuffer=null;
+			newClassfileBuffer= cc.toBytecode();
+//			cc.writeFile();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	private static void updateGetConnectionMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod=cc.getDeclaredMethod("getConnection", null);
+		log("*** Changing createStatement method ");
+//		serviceMethod.insertBefore(getGetConnectionMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getGetConnectionMethodAfterInsertCode());
+		
+	}
+	@SuppressWarnings("unused")
+	private static String getGetConnectionMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----BasicDataSource.getConnection() method is called\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	private static String getGetConnectionMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----BasicDataSource.getConnection() method is ended\");");
+//		sb.append("System.out.println(\"-----BasicDataSource.getConnection() \"+$0.getClass().getName());");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putConnection("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_GET_CONNECTION+",$0.getUrl());");
+		sb.append("}");
+		return sb.toString();
+	}
+	
+}
@@ -0,0 +1,75 @@
+package com.profiler.modifier.db.dbcp;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class DBCPPoolModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("DBCPPoolModifier(PoolingDataSource$PoolGuardConnectionWrapper) modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+//			updateGetConnectionMethod(classPool,cc);
+			updateCloseMethod(classPool,cc);
+/*
+			CtMethod[] methods=cc.getDeclaredMethods();
+			for(CtMethod method:methods) {
+//				System.out.println(method.getLongName());
+				if(!method.isEmpty() ) {
+					String methodName=method.getName();
+					if(methodName.equals("getConnection")) {
+//							&& !methodName.startsWith("version")) {
+						method.insertBefore("{System.out.println(\"-----DBCP "+method.getLongName()+" is started.\");}");
+						method.insertAfter("{System.out.println(\"-----DBCP "+method.getLongName()+" is finished.\");}");
+						System.out.println(method.getLongName());
+					}
+				} else {
+					log(method.getLongName()+" is empty !!!!!");
+				}
+			}
+*/
+			byte[] newClassfileBuffer=null;
+			newClassfileBuffer= cc.toBytecode();
+//			cc.writeFile();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	
+	
+	private static void updateCloseMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod=cc.getDeclaredMethod("close", null);
+		log("*** Changing close method ");
+//		serviceMethod.insertBefore(getCloseMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getCloseMethodAfterInsertCode());
+	}
+	
+	@SuppressWarnings("unused")
+	private static String getCloseMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----PoolingDataSource$PoolGuardConnectionWrapper.close() method is called\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	
+	private static String getCloseMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----PoolingDataSource$PoolGuardConnectionWrapper.close() method is ended\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".put("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_CLOSE_CONNECTION+");");
+		sb.append("}");
+		return sb.toString();
+	}
+}
@@ -0,0 +1,78 @@
+package com.profiler.modifier.db.mssql;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class MSSQLConnectionModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("MSSQLConnectionModifier modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethods(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethods(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateCreateStatementMethod(classPool,cc);
+			updateCloseMethod(classPool,cc);
+			byte[] newClassfileBuffer = cc.toBytecode();
+//			cc.writeFile();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	private static void updateCreateStatementMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtClass[] params=new CtClass[2];
+		params[0]=classPool.getCtClass("int");
+		params[1]=classPool.getCtClass("int");
+		CtMethod serviceMethod=cc.getDeclaredMethod("createStatement", params);
+		log("*** Changing createStatement method ");
+//		serviceMethod.insertBefore(getCreateStatementMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getCreateStatementMethodAfterInsertCode());
+	}
+	@SuppressWarnings("unused")
+	private static String getCreateStatementMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----ConnectionJDBC2.createStatement() method is called\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	private static String getCreateStatementMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----ConnectionJDBC2.createStatement() method is ended\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".put("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_CREATE_STATEMENT+");");
+		sb.append("}");
+		return sb.toString();
+	}
+	private static void updateCloseMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod=cc.getDeclaredMethod("close", null);
+		log("*** Changing close method ");
+//		serviceMethod.insertBefore(getCloseMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getCloseMethodAfterInsertCode());
+	}
+	@SuppressWarnings("unused")
+	private static String getCloseMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----ConnectionJDBC2.close() method is called\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	private static String getCloseMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----ConnectionJDBC2.close() method is ended\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".put("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_CLOSE_CONNECTION+");");
+		sb.append("}");
+		return sb.toString();
+	}
+}
@@ -0,0 +1,94 @@
+package com.profiler.modifier.db.mssql;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class MSSQLPreparedStatementModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("MSSQLPreparedStatementModifier modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateSetParameterMethod(classPool,cc);
+			updateExecuteQueryMethod(classPool,cc);
+			updateConstructor(classPool,cc);
+			byte[] newClassfileBuffer = cc.toBytecode();
+//			cc.writeFile();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	private static void updateSetParameterMethod(ClassPool classPool,CtClass cc) throws Exception {
+//		setParameter(int,java.lang.Object,int,int,int)
+		CtClass[] params1=new CtClass[5];
+		params1[0]=classPool.getCtClass("int");
+		params1[1]=classPool.getCtClass("java.lang.Object");
+		params1[2]=classPool.getCtClass("int");
+		params1[3]=classPool.getCtClass("int");
+		params1[4]=classPool.getCtClass("int");
+		CtMethod serviceMethod1=cc.getDeclaredMethod("setParameter", params1);
+		log("*** Changing setParameter(int,Object,int,int,int) method ");
+		serviceMethod1.insertBefore(getSetParameterBeforeInsertCode());
+		
+	}
+	private static String getSetParameterBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----JtdsPreparedStatement.setParameter(int,String,int,int,int) method is called\");");
+//		sb.append("System.out.println(\"-----Position=\"+$1+\" Value=\"+$2);");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putSqlParam($1,$2);");
+		sb.append("}");
+		return sb.toString();
+	}
+	private static void updateConstructor(ClassPool classPool,CtClass cc) throws Exception {
+		CtConstructor []constructorList=cc.getConstructors();
+		if(constructorList.length==1) {
+			log("*** Changing Constructor ");
+			CtConstructor constructor=constructorList[0];
+			constructor.insertAfter(getConstructorAfterInsertCode());
+		}
+	}
+	private static String getConstructorAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----JtdsPreparedStatement's constructor is called\");");
+//		sb.append("System.out.println(\"-----Query=[\"+com.profiler.util.QueryStringUtil.removeCarriageReturn($2)+\"]\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putSqlQuery("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_QUERY+",$2);");
+		sb.append("}");
+		return sb.toString();
+	}
+	private static void updateExecuteQueryMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod=cc.getDeclaredMethod("execute", null);
+		log("*** Changing executeQuery() method ");
+//		serviceMethod.insertBefore(getExecuteQueryMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getExecuteQueryMethodAfterInsertCode());
+	}
+	@SuppressWarnings("unused")
+	private static String getExecuteQueryMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----JtdsPreparedStatement.execute() method is called\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	private static String getExecuteQueryMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----JtdsPreparedStatement.execute() method is ended\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".put("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_EXECUTE_QUERY+");");
+		sb.append("}");
+		return sb.toString();
+		
+	}
+}
@@ -0,0 +1,60 @@
+package com.profiler.modifier.db.mssql;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class MSSQLResultSetModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("MSSQLResultSetModifier modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateNextMethod(classPool,cc);
+			updateCloseMethod(classPool,cc);
+			byte[] newClassfileBuffer = cc.toBytecode();
+//			cc.writeFile();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	private static void updateNextMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod1=cc.getDeclaredMethod("next", null);
+		log("*** Changing next() method ");
+		serviceMethod1.insertBefore(getNextMethodBeforeInsertCode());
+	}
+	private static String getNextMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"PreparedStatement.setInternal(int,String) method is called\");");
+//		sb.append("System.out.println(\"-----Position=\"+$1+\" Value=\"+$2);");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".updateFetchCount();");
+		sb.append("}");
+		return sb.toString();
+	}
+	private static void updateCloseMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod1=cc.getDeclaredMethod("close", null);
+		log("*** Changing close() method ");
+		serviceMethod1.insertBefore(getCloseMethodBeforeInsertCode());
+	}
+	private static String getCloseMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"PreparedStatement.setInternal(int,String) method is called\");");
+//		sb.append("System.out.println(\"-----Position=\"+$1+\" Value=\"+$2);");
+		
+//		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".put("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_RESULTSET_CLOSE+");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".addResultSetData();");
+		sb.append("}");
+		return sb.toString();
+	}
+}
@@ -0,0 +1,55 @@
+package com.profiler.modifier.db.mssql;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class MSSQLStatementModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("MSSQLStatementModifier modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateExecuteQueryMethod(classPool,cc);
+			byte[] newClassfileBuffer = cc.toBytecode();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	private static void updateExecuteQueryMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtClass[] params=new CtClass[1];
+		params[0]=classPool.getCtClass("java.lang.String");
+		CtMethod serviceMethod=cc.getDeclaredMethod("executeQuery", params);
+		log("*** Changing executeQuery method ");
+//		serviceMethod.insertBefore(getExecuteQueryMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getExecuteQueryMethodAfterInsertCode());
+	}
+	@SuppressWarnings("unused")
+	private static String getExecuteQueryMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----StatementImpl.executeQuery(String) method is called\");");
+//		sb.append("System.out.println(\"-----Query=[\"+com.profiler.util.QueryStringUtil.removeCarriageReturn($1)+\"]\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	private static String getExecuteQueryMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----StatementImpl.executeQuery(String) method is ended\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putSqlQuery("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_QUERY+",$1);");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".put("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_EXECUTE_QUERY+");");
+		sb.append("}");
+		return sb.toString();
+		
+	}
+}
@@ -0,0 +1,104 @@
+package com.profiler.modifier.db.mysql;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class MySQLConnectionImplModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("MySQLConnectionImplModifier modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethods(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethods(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateGetInstanceMethod(classPool,cc);
+			updateCreateStatementMethod(classPool,cc);
+			updateCloseMethod(classPool,cc);
+			byte[] newClassfileBuffer = cc.toBytecode();
+//			cc.writeFile();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	private static void updateCreateStatementMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod=cc.getDeclaredMethod("createStatement", null);
+		log("*** Changing createStatement method ");
+//		serviceMethod.insertBefore(getCreateStatementMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getCreateStatementMethodAfterInsertCode());
+	}
+	@SuppressWarnings("unused")
+	private static String getCreateStatementMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----ConnectionImpl.createStatement() method is called\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	private static String getCreateStatementMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----ConnectionImpl.createStatement() method is ended\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".put("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_CREATE_STATEMENT+");");
+		sb.append("}");
+		return sb.toString();
+	}
+	private static void updateGetInstanceMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtClass[] params=new CtClass[5];
+		params[0]=classPool.getCtClass("java.lang.String");
+		params[1]=classPool.getCtClass("int");
+		params[2]=classPool.getCtClass("java.util.Properties");
+		params[3]=classPool.getCtClass("java.lang.String");
+		params[4]=classPool.getCtClass("java.lang.String");
+		CtMethod serviceMethod=cc.getDeclaredMethod("getInstance", params);
+		log("*** Changing getInstance method ");
+//		serviceMethod.insertBefore(getGetInstanceMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getGetInstanceMethodAfterInsertCode());
+	}
+	@SuppressWarnings("unused")
+	private static String getGetInstanceMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----ConnectionImpl.getInstance() method is called\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	private static String getGetInstanceMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----ConnectionImpl.getInstance() method is ended\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putConnection("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_GET_CONNECTION+",$5);");
+		sb.append("}");
+		return sb.toString();
+	}
+	private static void updateCloseMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod=cc.getDeclaredMethod("close", null);
+		log("*** Changing close method ");
+//		serviceMethod.insertBefore(getCloseMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getCloseMethodAfterInsertCode());
+	}
+	@SuppressWarnings("unused")
+	private static String getCloseMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----ConnectionImpl.close() method is called\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	private static String getCloseMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----ConnectionImpl.close() method is ended\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".put("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_CLOSE_CONNECTION+");");
+		sb.append("}");
+		return sb.toString();
+	}
+}
@@ -0,0 +1,113 @@
+package com.profiler.modifier.db.mysql;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class MySQLPreparedStatementModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("MySQLPreparedStatementModifier modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateSetInternalMethod(classPool,cc);
+			updateExecuteQueryMethod(classPool,cc);
+			updateConstructor(classPool,cc);
+
+			byte[] newClassfileBuffer = cc.toBytecode();
+//			cc.writeFile();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	private static void updateSetInternalMethod(ClassPool classPool,CtClass cc) throws Exception {
+//		setInternal(int paramIndex, String   val)
+		CtClass[] params1=new CtClass[2];
+		params1[0]=classPool.getCtClass("int");
+		params1[1]=classPool.getCtClass("java.lang.String");
+		CtMethod serviceMethod1=cc.getDeclaredMethod("setInternal", params1);
+		log("*** Changing setInternal(int,String) method ");
+		serviceMethod1.insertBefore(getSetInternal1MethodBeforeInsertCode());
+		CtClass[] params2=new CtClass[2];
+		params2[0]=classPool.getCtClass("int");
+		params2[1]=classPool.getCtClass("byte[]");
+		CtMethod serviceMethod2=cc.getDeclaredMethod("setInternal", params2);
+		log("*** Changing setInternal(int,byte[]) method ");
+		serviceMethod2.insertBefore(getSetInternal2MethodBeforeInsertCode());
+		
+	}
+	private static String getSetInternal1MethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"PreparedStatement.setInternal(int,String) method is called\");");
+//		sb.append("System.out.println(\"-----Position=\"+$1+\" Value=\"+$2);");
+		
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putSqlParam($1,$2);");
+		sb.append("}");
+		return sb.toString();
+	}
+	private static String getSetInternal2MethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"PreparedStatement.setInternal(int,byte[]) method is called\");");
+//		sb.append("System.out.println(\"-----Position=\"+$1+\" Value=\"+new String($2));");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putSqlParam($1,$2);");
+		sb.append("}");
+		return sb.toString();
+	}
+	private static void updateConstructor(ClassPool classPool,CtClass cc) throws Exception {
+		CtConstructor []constructorList=cc.getConstructors();
+		if(constructorList.length==3) {
+			log("*** Changing Constructor ");
+			for(CtConstructor constructor:constructorList) {
+				CtClass params[]=constructor.getParameterTypes();
+				if(params.length==3) {
+					constructor.insertBefore(getConstructorBeforeInsertCode());
+				}
+			}
+		}
+	}
+	private static String getConstructorBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----PreparedStatement's constructor is called\");");
+//		sb.append("System.out.println(\"-----Query=[\"+$2+\"]\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putSqlQuery("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_QUERY+",$2);");
+		sb.append("}");
+		return sb.toString();
+	}
+	
+	private static void updateExecuteQueryMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod=cc.getDeclaredMethod("executeQuery", null);
+		log("*** Changing executeQuery method ");
+//		serviceMethod.insertBefore(getExecuteQueryMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getExecuteQueryMethodAfterInsertCode());
+	}
+	@SuppressWarnings("unused")
+	private static String getExecuteQueryMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----PreparedStatement.executeQuery() method is called\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	private static String getExecuteQueryMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----PreparedStatement.executeQuery() method is ended\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".put("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_EXECUTE_QUERY+");");
+		sb.append("}");
+		return sb.toString();
+		
+	}
+}
@@ -0,0 +1,58 @@
+package com.profiler.modifier.db.mysql;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class MySQLResultSetModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("ResultSetImpl modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateNextMethod(classPool,cc);
+			updateCloseMethod(classPool,cc);
+			byte[] newClassfileBuffer = cc.toBytecode();
+//			cc.writeFile();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	private static void updateNextMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod1=cc.getDeclaredMethod("next", null);
+		log("*** Changing next() method ");
+		serviceMethod1.insertBefore(getNextMethodBeforeInsertCode());
+	}
+	private static String getNextMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"PreparedStatement.setInternal(int,String) method is called\");");
+//		sb.append("System.out.println(\"-----Position=\"+$1+\" Value=\"+$2);");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".updateFetchCount();");
+		sb.append("}");
+		return sb.toString();
+	}
+	private static void updateCloseMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod1=cc.getDeclaredMethod("close", null);
+		log("*** Changing close() method ");
+		serviceMethod1.insertBefore(getCloseMethodBeforeInsertCode());
+	}
+	private static String getCloseMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"PreparedStatement.setInternal(int,String) method is called\");");
+//		sb.append("System.out.println(\"-----Position=\"+$1+\" Value=\"+$2);");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".addResultSetData();");
+		sb.append("}");
+		return sb.toString();
+	}
+}
@@ -0,0 +1,55 @@
+package com.profiler.modifier.db.mysql;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class MySQLStatementModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("MySQLStatementModifier modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateExecuteQueryMethod(classPool,cc);
+			byte[] newClassfileBuffer = cc.toBytecode();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	private static void updateExecuteQueryMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtClass[] params=new CtClass[1];
+		params[0]=classPool.getCtClass("java.lang.String");
+		CtMethod serviceMethod=cc.getDeclaredMethod("executeQuery", params);
+		log("*** Changing executeQuery method ");
+//		serviceMethod.insertBefore(getExecuteQueryMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getExecuteQueryMethodAfterInsertCode());
+	}
+	@SuppressWarnings("unused")
+	private static String getExecuteQueryMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----StatementImpl.executeQuery(String) method is called\");");
+//		sb.append("System.out.println(\"-----Query=[\"+$1+\"]\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	private static String getExecuteQueryMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----StatementImpl.executeQuery(String) method is ended\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putSqlQuery("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_QUERY+",$1);");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".put("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_EXECUTE_QUERY+");");
+		sb.append("}");
+		return sb.toString();
+		
+	}
+}
@@ -0,0 +1,119 @@
+package com.profiler.modifier.db.oracle;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class OraclePreparedStatementModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("OraclePreparedStatementModifier modifing");
+//		printClassInfo(javassistClassName);
+//		return addBeforeAfterLogics(classPool,javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+//		return null;
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateSetInternalMethod(classPool,cc);
+			updateExecuteMethod(classPool,cc);
+			updateConstructor(classPool,cc);
+
+			byte[] newClassfileBuffer = cc.toBytecode();
+//			cc.writeFile();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	private static void updateSetInternalMethod(ClassPool classPool,CtClass cc) throws Exception {
+//		setInternal(int paramIndex, String   val)
+		CtClass[] params1=new CtClass[2];
+		params1[0]=classPool.getCtClass("int");
+		params1[1]=classPool.getCtClass("java.lang.String");
+		CtMethod serviceMethod1=cc.getDeclaredMethod("setStringInternal", params1);
+		log("*** Changing setInternal(int,String) method ");
+		serviceMethod1.insertBefore(getSetInternal1MethodBeforeInsertCode());
+//		CtClass[] params2=new CtClass[2];
+//		params2[0]=classPool.getCtClass("int");
+//		params2[1]=classPool.getCtClass("byte[]");
+//		CtMethod serviceMethod2=cc.getDeclaredMethod("setInternal", params2);
+//		log("*** Changing setInternal(int,byte[]) method ");
+//		serviceMethod2.insertBefore(getSetInternal2MethodBeforeInsertCode());
+		
+	}
+	private static String getSetInternal1MethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"PreparedStatement.setInternal(int,String) method is called\");");
+//		sb.append("System.out.println(\"-----Position=\"+$1+\" Value=\"+$2);");
+		
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putSqlParam($1,$2);");
+		sb.append("}");
+		return sb.toString();
+	}
+	private static String getSetInternal2MethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"PreparedStatement.setInternal(int,byte[]) method is called\");");
+//		sb.append("System.out.println(\"-----Position=\"+$1+\" Value=\"+new String($2));");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putSqlParam($1,$2);");
+		sb.append("}");
+		return sb.toString();
+	}
+	private static void updateConstructor(ClassPool classPool,CtClass cc) throws Exception {
+		CtConstructor []constructorList=cc.getConstructors();
+//		if(constructorList.length==3) {
+		log("*** Changing Constructor ");
+		for(CtConstructor constructor:constructorList) {
+			CtClass params[]=constructor.getParameterTypes();
+//			System.out.println(params.length);
+//			for(CtClass param:params) {
+//				System.out.println(param.getName());
+//			}
+			if(params.length==6) {
+				constructor.insertBefore(getConstructorBeforeInsertCode());
+			}
+		}
+//		}
+	}
+	private static String getConstructorBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----PreparedStatement's constructor is called\");");
+//		sb.append("System.out.println(\"-----Query=[\"+$2+\"]\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putSqlQuery("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_QUERY+",$2);");
+		sb.append("}");
+		return sb.toString();
+	}
+	
+	private static void updateExecuteMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod=cc.getDeclaredMethod("execute", null);
+		log("*** Changing execute method ");
+//		serviceMethod.insertBefore(getExecuteQueryMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getExecuteMethodAfterInsertCode());
+	}
+	@SuppressWarnings("unused")
+	private static String getExecuteQueryMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----PreparedStatement.executeQuery() method is called\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	private static String getExecuteMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----PreparedStatement.executeQuery() method is ended\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".put("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_EXECUTE_QUERY+");");
+		sb.append("}");
+		return sb.toString();
+		
+	}
+}
@@ -0,0 +1,58 @@
+package com.profiler.modifier.db.oracle;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class OracleResultSetModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("OracleResultSetImpl modifing");
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateNextMethod(classPool,cc);
+			updateCloseMethod(classPool,cc);
+			byte[] newClassfileBuffer = cc.toBytecode();
+//			cc.writeFile();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	private static void updateNextMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod1=cc.getDeclaredMethod("next", null);
+		log("*** Changing next() method ");
+		serviceMethod1.insertBefore(getNextMethodBeforeInsertCode());
+	}
+	private static String getNextMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"PreparedStatement.setInternal(int,String) method is called\");");
+//		sb.append("System.out.println(\"-----Position=\"+$1+\" Value=\"+$2);");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".updateFetchCount();");
+		sb.append("}");
+		return sb.toString();
+	}
+	private static void updateCloseMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtMethod serviceMethod1=cc.getDeclaredMethod("close", null);
+		log("*** Changing close() method ");
+		serviceMethod1.insertBefore(getCloseMethodBeforeInsertCode());
+	}
+	private static String getCloseMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"PreparedStatement.setInternal(int,String) method is called\");");
+//		sb.append("System.out.println(\"-----Position=\"+$1+\" Value=\"+$2);");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".addResultSetData();");
+		sb.append("}");
+		return sb.toString();
+	}
+}
@@ -0,0 +1,57 @@
+package com.profiler.modifier.db.oracle;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.modifier.AbstractModifier;
+
+public class OracleStatementModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("OracleStatementModifier modifing");
+//		printClassInfo(javassistClassName);
+//		return addBeforeAfterLogics(classPool,javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			updateExecuteQueryMethod(classPool,cc);
+			byte[] newClassfileBuffer = cc.toBytecode();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	private static void updateExecuteQueryMethod(ClassPool classPool,CtClass cc) throws Exception {
+		CtClass[] params=new CtClass[1];
+		params[0]=classPool.getCtClass("java.lang.String");
+//		CtMethod serviceMethod=cc.getDeclaredMethod("executeQuery", params);
+		CtMethod serviceMethod=cc.getDeclaredMethod("execute", params);
+		log("*** Changing executeQuery method ");
+//		serviceMethod.insertBefore(getExecuteQueryMethodBeforeInsertCode());
+		serviceMethod.insertAfter(getExecuteQueryMethodAfterInsertCode());
+	}
+	@SuppressWarnings("unused")
+	private static String getExecuteQueryMethodBeforeInsertCode() {
+		StringBuilder sb=new StringBuilder();
+//		sb.append("{");
+//		sb.append("System.out.println(\"-----StatementImpl.executeQuery(String) method is called\");");
+//		sb.append("System.out.println(\"-----Query=[\"+$1+\"]\");");
+//		sb.append("}");
+		return sb.toString();
+	}
+	private static String getExecuteQueryMethodAfterInsertCode() {
+		StringBuilder sb=new StringBuilder();
+		sb.append("{");
+//		sb.append("System.out.println(\"-----StatementImpl.executeQuery(String) method is ended\");");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".putSqlQuery("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_QUERY+",$1);");
+		sb.append(TomcatProfilerConstant.CLASS_NAME_REQUEST_DATA_TRACER+".put("+TomcatProfilerConstant.REQ_DATA_TYPE_DB_EXECUTE_QUERY+");");
+		sb.append("}");
+		return sb.toString();
+		
+	}
+}
@@ -0,0 +1,114 @@
+package com.profiler.modifier.tomcat;
+
+import static com.profiler.config.TomcatProfilerConstant.CLASS_NAME_REQUEST_TRACER;
+import static com.profiler.config.TomcatProfilerConstant.CLASS_NAME_REQUEST_THRIFT_DTO;
+import javassist.ByteArrayClassPath;
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import com.profiler.modifier.AbstractModifier;
+/** 
+ * Modify org.apache.catalina.core.StandardHostValve class
+ * @author cowboy93
+ *
+ */
+public class EntryPointStandardHostValveModifier extends AbstractModifier {
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+		log("EntryPointModifier.modifyStandardHostValve()");
+//		printClassInfo(javassistClassName);
+		return changeServiceMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	private static byte[] changeServiceMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		classPool.insertClassPath(new ByteArrayClassPath(javassistClassName, classfileBuffer));
+		try {
+			addRequestTracerToCurrentClassLoader(classLoader);
+//			log("Class loader="+classPool.getClassLoader().toString());
+			CtClass cc = classPool.get(javassistClassName);
+			CtClass[] params=new CtClass[2];
+			
+			params[0]=classPool.getCtClass("org.apache.catalina.connector.Request");
+			params[1]=classPool.getCtClass("org.apache.catalina.connector.Response");
+			CtMethod serviceMethod=cc.getDeclaredMethod("invoke", params);
+			log("*** Changing invoke method ");
+			serviceMethod.insertBefore(getInvokeMethodBeforeInsertCode());
+			serviceMethod.insertAfter(getInvokeMethodAfterInsertCode());
+			
+			CtClass exceptionType = classPool.get("java.lang.Throwable");
+			//CtClass exceptionType = classPool.get("java.lang.Exception");
+			serviceMethod.addCatch(getInvokeMethodCatchInsertCode(), exceptionType);
+			
+//			cc.stopPruning(true);
+//			cc.toClass(classLoader,classLoader.getClass().getProtectionDomain());
+//			cc.stopPruning(false);
+			
+			byte[] newClassfileBuffer = cc.toBytecode();
+//			cc.writeFile();
+			printClassConvertComplete(javassistClassName);
+			return newClassfileBuffer;
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	private static String getInvokeMethodBeforeInsertCode() {
+		StringBuilder insertCode=new StringBuilder();
+		insertCode.append("{");
+		insertCode.append("long requestTime=System.currentTimeMillis();");
+		
+		insertCode.append("javax.servlet.http.HttpServletRequest tempRequest=(javax.servlet.http.HttpServletRequest)$1;");
+		insertCode.append("String requestURL=tempRequest.getRequestURI();");
+		insertCode.append("String clientIP=tempRequest.getRemoteAddr();");
+		insertCode.append(getParameterValues());
+		insertCode.append(CLASS_NAME_REQUEST_TRACER).append(".startTransaction(requestURL,clientIP,requestTime,params);");
+		
+//		insertCode.append("System.out.println(\"--- ApplicationFilterChain.doFilter() is started.\");");
+		insertCode.append("}");
+		return insertCode.toString();
+	}
+	private static StringBuilder getParameterValues() {
+		StringBuilder insertCode=new StringBuilder();
+		insertCode.append("java.util.Enumeration attrs=tempRequest.getParameterNames();");
+		insertCode.append("StringBuilder params=new StringBuilder();");
+		insertCode.append("while(attrs.hasMoreElements()) {");
+		insertCode.append("String keyString=attrs.nextElement().toString();");
+//		insertCode.append("System.out.println(key+\"=\"+tempRequest.getParameter(key.toString()));");
+		insertCode.append("Object value=tempRequest.getParameter(keyString);");
+		insertCode.append("if(value!=null) {");
+		insertCode.append("String valueString=value.toString();");
+		insertCode.append("int valueStringLength=valueString.length();");
+		insertCode.append("if(valueStringLength>0 && valueStringLength<100) params.append(keyString).append(\"=\").append(valueString).append(\",\");");
+		insertCode.append("}}");
+//		insertCode.append("System.out.println(params);");
+		return insertCode;
+	}
+	private static String getInvokeMethodAfterInsertCode() {
+		StringBuilder insertCode=new StringBuilder();
+		insertCode.append("{");
+		insertCode.append(CLASS_NAME_REQUEST_TRACER).append(".endTransaction();");
+//		insertCode.append("System.out.println(\"--- ApplicationFilterChain.doFilter() is ended.\");");
+		insertCode.append("}");
+		return insertCode.toString();
+	}
+	private static String getInvokeMethodCatchInsertCode() {
+		StringBuilder insertCode=new StringBuilder();
+//		insertCode.append("{");
+//		insertCode.append("System.out.println(\"------------------------------------------------\");");
+//		insertCode.append("System.out.println(\"--- \"+$e.getMessage()+\" is occured !!!\");");
+		insertCode.append(CLASS_NAME_REQUEST_TRACER).append(".exceptionTransaction($e);");
+//		insertCode.append("System.out.println(\"------------------------------------------------\");");
+		insertCode.append("throw $e;");
+//		insertCode.append("}");
+		return insertCode.toString();
+	}
+	private static void addRequestTracerToCurrentClassLoader(ClassLoader classLoader) {
+		try {
+			classLoader.loadClass(CLASS_NAME_REQUEST_TRACER);
+			classLoader.loadClass(CLASS_NAME_REQUEST_THRIFT_DTO);
+			classLoader.loadClass("org.apache.thrift.TBase");
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+	}
+}
@@ -0,0 +1,37 @@
+package com.profiler.modifier.tomcat;
+
+import com.profiler.modifier.AbstractModifier;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+/**
+ * When org.apache.catalina.core.StandardService class is loaded in ClassLoader,
+ * this class modifies methods.
+ * @author cowboy93
+ *
+ */
+public class TomcatConnectorModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	public static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			
+			CtClass param[]=new CtClass[1];
+			param[0]=classPool.getCtClass("int");
+			CtMethod setPortMethod=cc.getDeclaredMethod("setPort", param);
+			setPortMethod.insertBefore("{" +
+//					"System.out.println(\"*** setPort() method  *** Port number=\"+$1);" +
+					"com.profiler.dto.AgentInfoDTO.portNumberBuffer.append($1).append(\" \");"+
+					"}");
+			printClassConvertComplete(javassistClassName);
+			return cc.toBytecode();
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+}
@@ -0,0 +1,42 @@
+package com.profiler.modifier.tomcat;
+
+import static com.profiler.config.TomcatProfilerConstant.CLASS_NAME_AGENT_STATE_MANAGER;
+
+import com.profiler.modifier.AbstractModifier;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+/**
+ * When org.apache.catalina.core.StandardService class is loaded in ClassLoader,
+ * this class modifies methods.
+ * @author cowboy93
+ *
+ */
+public class TomcatStandardServiceModifier extends AbstractModifier{
+	public static byte[] modify(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classFileBuffer) {
+//		printClassInfo(javassistClassName);
+		return changeMethod(classPool,classLoader,javassistClassName,classFileBuffer);
+	}
+	public static byte[] changeMethod(ClassPool classPool,ClassLoader classLoader,String javassistClassName,byte[] classfileBuffer) {
+		try {
+			CtClass cc = classPool.get(javassistClassName);
+			CtMethod startMethod=cc.getDeclaredMethod("start", null);
+			startMethod.insertBefore("{" +
+					"System.out.println(\"*** Start TomcatProfiler JVMStat Thread ***\");" +
+					CLASS_NAME_AGENT_STATE_MANAGER+".startJVMTraceThread();" +
+					"}");
+			CtMethod stopMethod=cc.getDeclaredMethod("stop", null);
+			stopMethod.insertBefore("{" +
+					"System.out.println(\"*** TomcatProfiler send JVM is stopped info ***\");" +
+					CLASS_NAME_AGENT_STATE_MANAGER+".sendJVMStoppedInfo();" +
+					"}");
+			
+			printClassConvertComplete(javassistClassName);
+			return cc.toBytecode();
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+}
@@ -0,0 +1,30 @@
+package com.profiler.receiver;
+
+import java.io.InputStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+import com.profiler.config.TomcatProfilerConfig;
+
+public class TCPSocketManager extends Thread{
+	ServerSocket serverSocket=null;
+	public TCPSocketManager() {
+	}
+	public void run() {
+		try {
+			serverSocket=new ServerSocket(TomcatProfilerConfig.AGENT_TCP_LISTEN_PORT, 100);
+			System.out.println("*** Start TomcatProfiler TCP Listen Thread ***");
+			while(true) {
+				Socket socket=serverSocket.accept();
+				InputStream stream=socket.getInputStream();
+				byte[] readData=new byte[1024];
+				stream.read(readData);
+				System.out.println(new String(readData));
+			}
+//		} catch(InterruptedException ie) {
+			
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+	}
+}
@@ -0,0 +1,34 @@
+package com.profiler.sender;
+
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetSocketAddress;
+
+public abstract class AbstractDataSender {
+	public void send() {
+		try {
+			byte [] sendData=getSendData();
+			int sendDataLength=sendData.length;
+			
+//			System.out.println("sendDataLength="+sendDataLength);
+			
+			InetSocketAddress address=getAddress();
+			DatagramPacket packet=new DatagramPacket(sendData,sendDataLength,address);
+			
+			DatagramSocket udpSocket=new DatagramSocket();
+//			System.out.println("sendBufferSize="+udpSocket.getSendBufferSize());
+			udpSocket.send(packet);
+//			if(this instanceof RequestDataSender || this instanceof RequestTransactionDataSender ) {
+//				System.out.println(this.getClass().getName()+" Send bufferSize="+udpSocket.getSendBufferSize()+" dataLength="+sendDataLength);
+//			}
+			udpSocket.close();
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+	}
+	protected abstract byte[] getSendData() throws Exception;
+	protected abstract InetSocketAddress getAddress() throws Exception;
+	public void log(String message) {
+//		System.out.println("[AbstractDataSenderThread] "+message);
+	}
+}
@@ -0,0 +1,87 @@
+package com.profiler.sender;
+
+import java.io.ObjectOutputStream;
+import java.net.Socket;
+
+import com.profiler.config.TomcatProfilerConfig;
+import com.profiler.dto.AgentInfoDTO;
+
+public class AgentInfoSender extends Thread{
+	boolean isAgentStart;
+	public AgentInfoSender(boolean isAgentStart) {
+		this.isAgentStart=isAgentStart;
+	}
+	Socket requestSocket=null;
+	public void run() {
+		if(isAgentStart) {
+			sendAgentStartInfo();
+		} else {
+			sendAgentStopInfo();
+		}
+	}
+	private void sendAgentStopInfo() {
+		try {
+			connectToServer();
+			ObjectOutputStream stream=new ObjectOutputStream(requestSocket.getOutputStream());
+			AgentInfoDTO dto=new AgentInfoDTO();
+			dto.setIsDead();
+			log(dto.toString());
+			stream.writeObject(dto);
+			stream.close();
+			log("Agent Stopped message is sent");
+		} catch(Exception e) {
+			log("AgentInfoSender Exception occured:"+e.getMessage());
+		} finally {
+			closeSocket();
+		}
+	}
+	private void sendAgentStartInfo() {
+
+		while(connectToServer()) {
+			try {
+			 	Thread.sleep(TomcatProfilerConfig.SERVER_CONNECT_RETRY_GAP);
+			} catch(Exception e) {
+				e.printStackTrace();
+			}
+		}
+		try {
+			ObjectOutputStream stream=new ObjectOutputStream(requestSocket.getOutputStream());
+//			stream.write(("AGENT_HASH="+JVMInfoDTO.hostHashCode).getBytes());
+//			stream.write(("AGENT_IP="+JVMInfoDTO.hostIP).getBytes());
+//			stream.write(("AGENT_PORT="+JVMInfoDTO.portNumber).getBytes());
+			AgentInfoDTO dto=new AgentInfoDTO();
+			log(dto.toString());
+			stream.writeObject(dto);
+			stream.close();
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+		if(requestSocket!=null) {
+			closeSocket();
+		}
+	}
+	private void log(String message) {
+		System.out.println("*** "+message);
+	}
+	private boolean connectToServer() {
+		try {
+			requestSocket=new Socket(TomcatProfilerConfig.SERVER_IP,TomcatProfilerConfig.SERVER_TCP_LISTEN_PORT);
+			log("Connected to server ");
+			return false;
+		} catch(java.net.ConnectException ce) {
+			log("Connect to TomcatProfiler server is failed ***");
+			return true;
+		} catch(Exception e) {
+			e.printStackTrace();
+			return true;
+		}
+	}
+	private void closeSocket() {
+		try {
+			requestSocket.close();
+			log("TCP RequestSocket is closed");
+		} catch (Exception e) {
+//			e.printStackTrace();
+		}
+	}
+}
@@ -0,0 +1,24 @@
+package com.profiler.sender;
+
+import java.net.InetSocketAddress;
+
+import org.apache.thrift.TSerializer;
+import org.apache.thrift.protocol.TBinaryProtocol;
+
+import com.profiler.config.TomcatProfilerConfig;
+import com.profiler.dto.JVMInfoThriftDTO;
+
+public class JVMDataSender extends AbstractDataSender{
+	JVMInfoThriftDTO dto;
+	public JVMDataSender(JVMInfoThriftDTO dto) {
+		this.dto=dto;
+		log(dto.toString());
+	}
+	protected byte[] getSendData() throws Exception {
+		TSerializer serializer = new TSerializer(new TBinaryProtocol.Factory());
+		return serializer.serialize(dto);
+	}
+	protected InetSocketAddress getAddress() throws Exception {
+		return new InetSocketAddress(TomcatProfilerConfig.SERVER_IP, TomcatProfilerConfig.JVM_DATA_LISTEN_PORT);
+	}
+}
@@ -0,0 +1,32 @@
+package com.profiler.sender;
+
+import java.net.InetSocketAddress;
+
+import org.apache.thrift.TSerializer;
+import org.apache.thrift.protocol.TBinaryProtocol;
+
+import com.profiler.config.TomcatProfilerConfig;
+import com.profiler.dto.RequestDataListThriftDTO;
+
+public class RequestDataSender extends AbstractDataSender{
+	RequestDataListThriftDTO dto;
+	public RequestDataSender(RequestDataListThriftDTO dto) {
+		this.dto=dto;
+//		log(dto.toString());
+	}
+	@Override
+	protected byte[] getSendData() throws Exception {
+		TSerializer serializer = new TSerializer(new TBinaryProtocol.Factory());
+//		byte[] serializedBytes=serializer.serialize(dto);
+//		System.out.println("-----Request Data size="+serializedBytes.length);
+//		return serializedBytes;
+		return serializer.serialize(dto);
+	}
+
+	@Override
+	protected InetSocketAddress getAddress() throws Exception {
+		return new InetSocketAddress(TomcatProfilerConfig.SERVER_IP, TomcatProfilerConfig.REQUEST_DATA_LISTEN_PORT);
+	}
+
+
+}
@@ -0,0 +1,30 @@
+package com.profiler.sender;
+
+import java.net.InetSocketAddress;
+
+import org.apache.thrift.TSerializer;
+import org.apache.thrift.protocol.TBinaryProtocol;
+
+import com.profiler.config.TomcatProfilerConfig;
+import com.profiler.dto.RequestThriftDTO;
+
+public class RequestTransactionDataSender extends AbstractDataSender{
+	RequestThriftDTO dto;
+	public RequestTransactionDataSender(RequestThriftDTO dto) {
+		this.dto=dto;
+//		log(dto.toString());
+	}
+	@Override
+	protected byte[] getSendData() throws Exception {
+		TSerializer serializer = new TSerializer(new TBinaryProtocol.Factory());
+//		byte[] serializedBytes=serializer.serialize(dto);
+//		System.out.println("-----Request Transaction Data size="+serializedBytes.length);
+//		return serializedBytes;
+		return serializer.serialize(dto);
+	}
+
+	@Override
+	protected InetSocketAddress getAddress() throws Exception {
+		return new InetSocketAddress(TomcatProfilerConfig.SERVER_IP, TomcatProfilerConfig.REQUEST_TRANSACTION_DATA_LISTEN_PORT);
+	}
+}
@@ -0,0 +1,15 @@
+package com.profiler.thread;
+
+import com.profiler.sender.AgentInfoSender;
+
+public class AgentStateManager {
+    public static void startJVMTraceThread() {
+        CurrentJVMStateCheckThread tracer = new CurrentJVMStateCheckThread();
+        tracer.setDaemon(true);
+        tracer.start();
+    }
+    public static void sendJVMStoppedInfo() throws Exception {
+        AgentInfoSender sender = new AgentInfoSender(false);
+        sender.start();
+    }
+}
@@ -0,0 +1,147 @@
+package com.profiler.thread;
+import static com.profiler.config.TomcatProfilerConfig.JVM_STAT_GAP;
+
+import java.lang.management.GarbageCollectorMXBean;
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryMXBean;
+import java.lang.management.MemoryUsage;
+import java.net.InetAddress;
+import java.util.List;
+
+import com.profiler.dto.AgentInfoDTO;
+import com.profiler.dto.JVMInfoThriftDTO;
+import com.profiler.sender.AgentInfoSender;
+import com.profiler.sender.JVMDataSender;
+import com.profiler.trace.RequestTransactionTracer;
+import com.sun.management.OperatingSystemMXBean;
+@SuppressWarnings("restriction")
+public class CurrentJVMStateCheckThread extends Thread {
+	JVMInfoThriftDTO currentDto=new JVMInfoThriftDTO();
+	public void run() {
+		setHostIPandPort();
+		
+		long gap=0;
+		while(true) {
+			try {
+				if(JVM_STAT_GAP>=gap) {
+					long currentMod=System.currentTimeMillis()%1000;
+					Thread.sleep(JVM_STAT_GAP-gap-currentMod+1);
+				} 
+				long startTime=System.currentTimeMillis();
+				
+				sendJVMState();
+				
+				long endTime=System.currentTimeMillis();
+				gap=endTime-startTime;
+//				System.out.println(gap);
+			} catch(java.util.concurrent.RejectedExecutionException ree) {
+//				System.out.println(ree.getMessage());
+//				ree.printStackTrace();
+				System.out.println("RejectedExecutionException when sending JVM State info ");
+			} catch(Exception e) {
+				e.printStackTrace();
+			}
+		}
+	}
+	/**
+	 * This method run only one time and send current agent's information.
+	 * 
+	 * It check's host IP and port.
+	 * After then make hashCode of IP+Port string. 
+	 * This hashCode is always different with others. 
+	 */
+	private void setHostIPandPort() {
+		AgentInfoDTO.staticPortNumber=AgentInfoDTO.getPortNumberString();
+		String hostIP=null;
+		try {
+			InetAddress thisIp =InetAddress.getLocalHost();
+			hostIP=thisIp.getHostAddress();
+		} catch(Exception e) {
+			e.printStackTrace();
+			hostIP="127.0.0.1";
+		}
+		AgentInfoDTO.staticHostIP=hostIP;
+		System.out.println("*** TomcatProfiler : HostIP="+hostIP+" PortNumbers="+AgentInfoDTO.staticPortNumber);
+		AgentInfoDTO.staticHostHashCode=(hostIP+AgentInfoDTO.staticPortNumber).hashCode();
+
+		AgentInfoSender sender=new AgentInfoSender(true);
+		sender.start();
+	}
+	/**
+	 * Every JVM_STAT_GAP time, this method is called
+	 * @throws Exception
+	 */
+	private void sendJVMState() throws Exception {
+		currentDto=new JVMInfoThriftDTO();
+		currentDto.setAgentHashCode(AgentInfoDTO.staticHostHashCode);
+		currentDto.setDataTime(System.currentTimeMillis());
+		getActiveThreadCount();
+		getGCState();
+		getMemoryState();
+		getProcessCPUUsage();
+		JVMDataSender sender=new JVMDataSender(currentDto);
+		sender.send();
+	}
+	private void getActiveThreadCount() throws Exception {
+		int currentSize=RequestTransactionTracer.getActiveThreadCount();
+		currentDto.setActiveThreadCount(currentSize);
+//		JVMDataSender sender=new JVMDataSender(dto);
+//		sender.send();
+	}
+	
+	
+	private void getGCState() throws Exception {
+		List<GarbageCollectorMXBean> list=ManagementFactory.getGarbageCollectorMXBeans();
+		if(list.size()==2) {
+			GarbageCollectorMXBean bean1=list.get(0);
+			currentDto.setGc1Count(bean1.getCollectionCount());
+			currentDto.setGc1Time(bean1.getCollectionTime());
+			GarbageCollectorMXBean bean2=list.get(1);
+			currentDto.setGc2Count(bean2.getCollectionCount());
+			currentDto.setGc2Time(bean2.getCollectionTime());
+		}
+	}
+	
+	public void getMemoryState() throws Exception {
+		MemoryMXBean bean=ManagementFactory.getMemoryMXBean();
+		MemoryUsage heap=bean.getHeapMemoryUsage();
+		MemoryUsage nonHeap=bean.getNonHeapMemoryUsage();
+		
+		currentDto.setHeapUsed(heap.getUsed());
+		currentDto.setHeapCommitted(heap.getCommitted());
+		currentDto.setNonHeapUsed(nonHeap.getUsed());
+		currentDto.setNonHeapCommitted(nonHeap.getCommitted());
+	}
+	long previousCpuTime=0;
+	int processorCount=-1;
+	boolean processCPUAvailable=true;
+	/**
+	 * I don't know why should I divide by 10 in this result. 
+	 * But it works. - -;
+	 * @throws Exception
+	 */
+	private void getProcessCPUUsage() throws Exception {
+		try {
+			if(processCPUAvailable) {
+				OperatingSystemMXBean sunOSMBean  = ManagementFactory.newPlatformMXBeanProxy(
+						ManagementFactory.getPlatformMBeanServer(),
+						ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME,
+						OperatingSystemMXBean.class);
+				long cpuTime=sunOSMBean.getProcessCpuTime();
+				if(processorCount==-1) {
+					processorCount=sunOSMBean.getAvailableProcessors();
+				}
+//				System.out.println(cpuTime);
+				if(previousCpuTime!=0) {
+					long usedCPUTotal=(cpuTime-previousCpuTime)/1000000;
+					double usedCPU=(0.1D*usedCPUTotal)/(processorCount*JVM_STAT_GAP/1000.0);
+					currentDto.setProcessCPUTime(usedCPU);
+				}
+				previousCpuTime=cpuTime;
+			}
+		} catch(Exception e) {
+//			e.printStackTrace();
+			processCPUAvailable=false;
+		}
+	}
+}
@@ -0,0 +1,15 @@
+package com.profiler.trace;
+
+public abstract class AbstractTracer {
+	public static void printStackTrace() {
+		log("#################################################");
+		StackTraceElement[] stackList=Thread.currentThread().getStackTrace();
+		int length=stackList.length;
+		for(int loop=2;loop<length;loop++) {
+			log(stackList[loop].toString());
+		}
+	}
+	protected static void log(String message) {
+		System.out.println("*** "+message);
+	}
+}
@@ -0,0 +1,294 @@
+package com.profiler.trace;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+import com.profiler.config.TomcatProfilerConfig;
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.dto.AgentInfoDTO;
+import com.profiler.dto.RequestDataListThriftDTO;
+import com.profiler.dto.RequestDataThriftDTO;
+import com.profiler.util.QueryStringUtil;
+
+public class RequestDataTracer {
+	private static Set<Integer> sqlSet=null;
+	private static Hashtable<Integer,String> dbConnectionURL=new Hashtable<Integer,String>();
+	static {
+		if(TomcatProfilerConfig.QUERY_COUNT_OVER_10000) { 
+			sqlSet=new CopyOnWriteArraySet<Integer>();
+		} else {
+			sqlSet=new HashSet<Integer>(1024);
+		}
+	} 
+	private static final ThreadLocal<RequestDataListThriftDTO> requestDataThreadLocal=new ThreadLocal<RequestDataListThriftDTO>();
+	private static final ThreadLocal<HashMap<Integer,String>> sqlParamMapThreadLocal=new ThreadLocal<HashMap<Integer,String>>();
+	
+	/**
+	 * These two variables are used counting "ResultSet.next()" times.
+	 */
+	private static final ThreadLocal<Integer> fetchCountThreadLocal=new ThreadLocal<Integer>();
+	private static final ThreadLocal<Integer> totalFetchCountThreadLocal=new ThreadLocal<Integer>();
+	public static RequestDataListThriftDTO getRequestDataList() {
+		return requestDataThreadLocal.get();
+	}
+	public static void removeRequestDataList() {
+		requestDataThreadLocal.remove();
+	}
+	private static boolean isRequestData() {
+		Integer reqHashCode=RequestTransactionTracer.getRequestHashCode();
+		if(reqHashCode==null) {
+			return false;
+		} else {
+			return true;
+		}
+	}
+
+	/** 
+	 * Put data to requestDataThreadLocal. 
+	 * @param dataType
+	 */
+	public static void put(int dataType) {
+//		System.out.println(dataType+"-----RequestHashCode="+RequestTransactionTracer.getRequestHashCode());
+		if(isRequestData()) { 
+			RequestDataListThriftDTO dto=requestDataThreadLocal.get();
+			dto=checkDTO(dto);
+			List<RequestDataThriftDTO> list=dto.getRequestDataList();
+	//		System.out.println("-----RequestDataListThriftDTO list size="+list.size());
+			
+			checkSqlParamMap(list);
+			
+			RequestDataThriftDTO dataDto=new RequestDataThriftDTO(dataType,System.currentTimeMillis());
+			list.add(dataDto);
+			requestDataThreadLocal.set(dto);
+		}
+	}
+	
+	/** 
+	 * Put Connection data to requestDataThreadLocal. 
+	 * @param dataType
+	 */
+	public static void putConnection(int dataType,String url) {
+//		System.out.println(dataType+"-----RequestHashCode="+RequestTransactionTracer.getRequestHashCode());
+		if(isRequestData()) { 
+			RequestDataListThriftDTO dto=requestDataThreadLocal.get();
+			dto=checkDTO(dto);
+			List<RequestDataThriftDTO> list=dto.getRequestDataList();
+	//		System.out.println("-----RequestDataListThriftDTO list size="+list.size());
+			
+			checkSqlParamMap(list);
+			
+			RequestDataThriftDTO dataDto=new RequestDataThriftDTO(dataType,System.currentTimeMillis());
+			if(url!=null) {
+				int hashCode=url.hashCode();
+				if(!dbConnectionURL.containsKey(hashCode)) {
+					dbConnectionURL.put(hashCode, url);
+					dataDto.setDataString(url);
+//					System.out.println(url);
+				} 
+				dataDto.setDataHashCode(hashCode);
+			}
+			list.add(dataDto);
+			requestDataThreadLocal.set(dto);
+		}
+	}
+	/** 
+	 * Put SQL Query data into requestDataThreadLocal. 
+	 * @param dataType
+	 */
+	public static void putSqlQuery(int dataType,String data) {
+		if(isRequestData()) {
+			RequestDataListThriftDTO dto=requestDataThreadLocal.get();
+			dto=checkDTO(dto);
+			List<RequestDataThriftDTO> list=dto.getRequestDataList();
+	//		System.out.println("-----RequestDataListThriftDTO list size="+list.size());
+			
+			checkSqlParamMap(list);
+			
+			RequestDataThriftDTO dataDto=new RequestDataThriftDTO(dataType,System.currentTimeMillis());
+			int dataHashCode=data.hashCode();
+			dataDto.setDataHashCode(dataHashCode);
+			boolean isAlreadySent=checkHashCode(dataHashCode);
+			if(!isAlreadySent) {
+				if(data!=null) {
+					dataDto.setDataString(QueryStringUtil.removeAllMultiSpace(data));
+				} 
+			}
+			list.add(dataDto);
+			requestDataThreadLocal.set(dto);
+		}
+	}
+	/**
+	 * Check SQL Query HashCode set.
+	 * If Query count is over 10000, it can make memory problem.
+	 * So this method removes 100 hashCode.
+	 * 
+	 * If you use HashSet this remove code will not run.
+	 * 
+	 * @param dataHashCode
+	 * @return
+	 */
+	private static boolean checkHashCode(int dataHashCode) {
+		if(TomcatProfilerConfig.QUERY_COUNT_OVER_10000) {
+			//If sqlSet is CopyOnWriteArraySet, it removes data.
+			if(sqlSet.size()>10000) {
+				Iterator<Integer> iterator=sqlSet.iterator();
+				for(int loop=0;loop<100;loop++) {
+					sqlSet.remove(iterator.next());
+				}
+			}
+		}
+		if(sqlSet.contains(dataHashCode)) {
+			return true;
+		} else {
+			sqlSet.add(dataHashCode);
+			return false;
+		}
+	}
+	/**
+	 * Manage sql param list
+	 * @param list
+	 */
+	private static void checkSqlParamMap(List<RequestDataThriftDTO> list) {
+		if(isRequestData()) {
+			HashMap<Integer,String> map=sqlParamMapThreadLocal.get();
+			if(map!=null) {
+				int mapSize=map.size();
+				StringBuilder params=new StringBuilder();
+				for(int loop=1;loop<=mapSize;loop++) {
+					params.append(map.get(loop)).append(",");
+				}
+				
+				RequestDataThriftDTO dataDto=new RequestDataThriftDTO(TomcatProfilerConstant.REQ_DATA_TYPE_DB_PREPARED_STATEMENT_PARAM,System.currentTimeMillis());
+				dataDto.setDataString(params.toString());
+				list.add(dataDto);
+			}
+			sqlParamMapThreadLocal.remove();
+		}
+	}
+	/**
+	 * Add sql parameter 
+	 * @param sequence
+	 * @param data
+	 */
+	public static void putSqlParam(int sequence,String data) {
+		if(isRequestData()) {
+			HashMap<Integer,String> map=sqlParamMapThreadLocal.get();
+			if(map==null) {
+				map=new HashMap<Integer,String>();
+			}
+//			if(data!=null) {
+//				try {
+//					System.out.print("Before="+data);
+//					String afterData1=new String(data.getBytes("MS949"), "ISO-8859-1");;
+//					System.out.print(" After1="+afterData1);
+//					String afterData1_1=new String(afterData1.getBytes("ISO-8859-1"), "EUC-KR");;
+//					System.out.print(" After1_1="+afterData1_1);
+//					
+//					
+//					String afterData3=new String(data.getBytes("ISO-8859-1"),"MS949");
+//					System.out.print(" After3="+afterData3);
+//					String afterData3_1=new String(afterData3.getBytes("MS949"),"EUC-KR");
+//					System.out.print(" After3_1="+afterData3_1);
+//
+//					String afterData5=new String(data.getBytes("ISO-8859-1"),"EUC-KR");
+//					System.out.print(" After5="+afterData5);
+//					String afterData6=new String(data.getBytes("MS949"),"EUC-KR");
+//					System.out.print(" After6="+afterData6);
+//					
+//					String afterData7=new String(data.getBytes(),"ISO-8859-1");
+//					System.out.print(" After7="+afterData7);
+//					
+//					System.out.println();
+//				} catch(Exception e) {
+//					e.printStackTrace();
+//				}
+//			}
+			map.put(sequence,data);
+			sqlParamMapThreadLocal.set(map);
+		}
+	}
+	public static void putSqlParam(int sequence,byte[] data) {
+		putSqlParam(sequence,new String(data));
+	}
+	public static void putSqlParam(int sequence,Object data) {
+		if(data!=null) {
+			putSqlParam(sequence,data.toString());
+		} else {
+			putSqlParam(sequence,"null");
+		}
+	}
+	/**
+	 * Check RequestDataListThriftDTO is null. 
+	 * If this object is null, current request called this Class first time.
+	 * So it make RequestDataListThriftDTO object. 
+	 * @param dto
+	 * @return
+	 */
+	private static RequestDataListThriftDTO checkDTO(RequestDataListThriftDTO dto) {
+		if(dto==null) {
+//			System.out.println("dto=null");
+			dto=new RequestDataListThriftDTO(AgentInfoDTO.staticHostHashCode,RequestTransactionTracer.getRequestHashCode(),new ArrayList<RequestDataThriftDTO>());
+		}
+		return dto;
+	}
+	/**
+	 * add ResultSet.next() method call count.
+	 */
+	public static void updateFetchCount() {
+		Integer totalFetchCount=totalFetchCountThreadLocal.get();
+		Integer fetchCount=fetchCountThreadLocal.get();
+		if(totalFetchCount==null) {
+			totalFetchCountThreadLocal.set(0);
+		}
+		if(fetchCount==null) {
+			fetchCountThreadLocal.set(0);
+		}
+		totalFetchCountThreadLocal.set(totalFetchCountThreadLocal.get()+1);
+		fetchCountThreadLocal.set(fetchCountThreadLocal.get()+1);
+	}
+
+	/**
+	 * Before transaction end, removes current thread's fetch count data.
+	 */
+	public static void removeFetchCount() {
+		totalFetchCountThreadLocal.remove();
+		fetchCountThreadLocal.remove();
+	}
+	/** 
+	 * If ResultSet.close() method is called,
+	 * this method is called.
+	 */
+	public static void addResultSetData() {
+		if(isRequestData()) { 
+			//set data fetch count
+			Integer fetchCount=fetchCountThreadLocal.get();
+			if(fetchCount!=null) { 
+				Integer totalFetchCount=totalFetchCountThreadLocal.get();
+				fetchCountThreadLocal.remove();
+				
+				RequestDataListThriftDTO dto=requestDataThreadLocal.get();
+				dto=checkDTO(dto);
+				List<RequestDataThriftDTO> list=dto.getRequestDataList();
+				int listSize=list.size();
+				RequestDataThriftDTO previousDTO=list.get(listSize-1);
+				if(previousDTO.getDataType()!=TomcatProfilerConstant.REQ_DATA_TYPE_DB_FETCH) {
+					RequestDataThriftDTO dataDto=new RequestDataThriftDTO(TomcatProfilerConstant.REQ_DATA_TYPE_DB_FETCH,System.currentTimeMillis());
+					dataDto.setExtraInt1(fetchCount);
+					dataDto.setExtraInt2(totalFetchCount);
+					list.add(dataDto);
+				} else {
+					//Because of MS SQL. 
+					int previousTotalFetchCount=previousDTO.getExtraInt2();
+					totalFetchCountThreadLocal.set(previousTotalFetchCount);
+				}
+				requestDataThreadLocal.set(dto);
+			}
+		}
+	}
+}
@@ -0,0 +1,110 @@
+package com.profiler.trace;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import com.profiler.config.TomcatProfilerConstant;
+import com.profiler.dto.AgentInfoDTO;
+import com.profiler.dto.RequestDataListThriftDTO;
+import com.profiler.dto.RequestThriftDTO;
+import com.profiler.sender.RequestDataSender;
+import com.profiler.sender.RequestTransactionDataSender;
+
+public class RequestTransactionTracer extends AbstractTracer {
+//	private static Hashtable<String,RequestThriftDTO> requestTable=new Hashtable<String,RequestThriftDTO>();
+	private static Set<String> requestSet=null;
+	static{
+		requestSet=Collections.synchronizedSet(new HashSet<String>());
+	}
+
+	public RequestTransactionTracer() {
+	}
+	private static final ThreadLocal<String> requestID=new ThreadLocal<String>();
+	private static final ThreadLocal<Integer> requestHashCode=new ThreadLocal<Integer>();
+	public static Integer getRequestHashCode() {
+		return requestHashCode.get();
+	}
+	public static void startTransaction(String requestURL,String clientIP,long requestTime,StringBuilder params) {
+//		printStackTrace();
+//		long cpuUserTime[]=getThreadTime();
+		long cpuUserTime[]=new long[2];
+		
+		String currentThreadName=Thread.currentThread().getName();
+		//### set Thread id with thread local
+		String tempRequestID=currentThreadName+"_"+System.nanoTime();
+		requestID.set(tempRequestID);
+		int tempRequestHashCode=tempRequestID.hashCode();
+		requestHashCode.set(tempRequestHashCode);
+		RequestThriftDTO dto=new RequestThriftDTO(AgentInfoDTO.staticHostHashCode,tempRequestHashCode,TomcatProfilerConstant.DATA_TYPE_REQUEST,requestTime,cpuUserTime[0],cpuUserTime[1]);
+		dto.setClientIP(clientIP);
+		dto.setRequestURL(requestURL);
+		int paramsLength=params.length();
+		if(paramsLength>0) {
+			params.deleteCharAt(paramsLength-1);
+			dto.setExtraData1(params.toString());
+		}
+		requestSet.add(requestID.get());
+		RequestTransactionDataSender sender=new RequestTransactionDataSender(dto);
+		sender.send();
+	}
+	/**
+	 * Transaction is successfully ended.
+	 */
+	public static void endTransaction() {
+//		long cpuUserTime[]=getThreadTime();
+		long cpuUserTime[]=new long[2];
+		RequestThriftDTO dto=new RequestThriftDTO(AgentInfoDTO.staticHostHashCode,requestHashCode.get(),TomcatProfilerConstant.DATA_TYPE_RESPONSE,System.currentTimeMillis(),cpuUserTime[0],cpuUserTime[1]);
+		
+		finishTransaction(dto);
+	}
+	/**
+	 * There was an Exception processing transaction.
+	 * @param throwable
+	 */
+	public static void exceptionTransaction(Throwable throwable) {
+//		long cpuUserTime[]=getThreadTime();
+		long cpuUserTime[]=new long[2];
+		RequestThriftDTO dto=new RequestThriftDTO(AgentInfoDTO.staticHostHashCode,requestHashCode.get(),TomcatProfilerConstant.DATA_TYPE_UNCAUGHT_EXCEPTION,System.currentTimeMillis(),cpuUserTime[0],cpuUserTime[1]);
+		dto.setExtraData1(throwable.getMessage());
+		StackTraceElement[] tempElement=throwable.getStackTrace();
+		dto.setExtraData2(tempElement[0].toString());
+		
+		finishTransaction(dto);
+	}
+	/**
+	 * Transaction is ended and send request end data
+	 * @param dto
+	 */
+	public static void finishTransaction(RequestThriftDTO dto) {
+		RequestDataListThriftDTO dataListDto=RequestDataTracer.getRequestDataList();
+		if(dataListDto!=null) {
+			RequestDataSender dSender=new RequestDataSender(dataListDto);
+			dSender.send();
+		}
+		RequestTransactionDataSender tSender=new RequestTransactionDataSender(dto);
+		tSender.send();
+		
+		requestSet.remove(requestID.get());
+		RequestDataTracer.removeRequestDataList();
+		
+		RequestDataTracer.removeFetchCount();
+	}
+	
+	public static int getActiveThreadCount() {
+		return requestSet.size();
+	}
+	/* If every time call Thread's CPU time 
+	 * it affect to TPS and CPU usage.
+	 * It is one of bottle neck.
+	public static long[] getThreadTime() {
+		long result[]=new long[2];
+		
+		ThreadMXBean bean=ManagementFactory.getThreadMXBean();
+//		System.out.println(Thread.currentThread().getName()+" CPU:"+bean.getCurrentThreadCpuTime()+" User:"+bean.getCurrentThreadUserTime());
+		result[0]=bean.getCurrentThreadCpuTime();
+		result[1]=bean.getCurrentThreadUserTime();
+		return result;
+	}
+	*/
+}
@@ -0,0 +1,18 @@
+package com.profiler.util;
+
+public class QueryStringUtil {
+//	public static void main(String args[]) {
+//		String a="a\nb\rc\n";
+//		
+//		System.out.println(QueryStringUtil.removeCarriageReturn(a));
+//	}
+	public static String removeCarriageReturn(String query) {
+//		query.replaceAll(regex, replacement)
+		String result= query.replaceAll("[\r\n]", " "); 
+		return result;
+	}
+	public static String removeAllMultiSpace(String query) {
+		String after = query.trim().replaceAll(" +", " ");
+		return after;
+	}
+}