diff --git a/.classpath b/.classpath new file mode 100644 index 000000000..d166a881d --- /dev/null +++ b/.classpath @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + diff --git a/.project b/.project new file mode 100644 index 000000000..46319fb6d --- /dev/null +++ b/.project @@ -0,0 +1,17 @@ + + + TomcatProfiler + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 000000000..0c9a29578 --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -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 diff --git a/HippoAgent.jar b/HippoAgent.jar new file mode 100644 index 000000000..edd9135ca Binary files /dev/null and b/HippoAgent.jar differ diff --git a/JVMInfoThriftDTO.thrift b/JVMInfoThriftDTO.thrift new file mode 100644 index 000000000..f71a5dc9f --- /dev/null +++ b/JVMInfoThriftDTO.thrift @@ -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 + +} diff --git a/RequestDataThriftDTO.thrift b/RequestDataThriftDTO.thrift new file mode 100644 index 000000000..349ac7fc1 --- /dev/null +++ b/RequestDataThriftDTO.thrift @@ -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 requestDataList +} diff --git a/RequestThriftDTO.thrift b/RequestThriftDTO.thrift new file mode 100644 index 000000000..020522cb5 --- /dev/null +++ b/RequestThriftDTO.thrift @@ -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 +} + diff --git a/TODO_List.txt b/TODO_List.txt new file mode 100644 index 000000000..db8065f11 --- /dev/null +++ b/TODO_List.txt @@ -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 \ No newline at end of file diff --git a/TomcatProfiler.jar b/TomcatProfiler.jar new file mode 100644 index 000000000..23f30e416 Binary files /dev/null and b/TomcatProfiler.jar differ diff --git a/abrun.sh b/abrun.sh new file mode 100644 index 000000000..99f20fe59 --- /dev/null +++ b/abrun.sh @@ -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 diff --git a/hippo.config b/hippo.config new file mode 100644 index 000000000..93a4a0188 --- /dev/null +++ b/hippo.config @@ -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 \ No newline at end of file diff --git a/lib/catalina.jar b/lib/catalina.jar new file mode 100644 index 000000000..a9bea06ba Binary files /dev/null and b/lib/catalina.jar differ diff --git a/lib/javassist.jar b/lib/javassist.jar new file mode 100644 index 000000000..e8abb1971 Binary files /dev/null and b/lib/javassist.jar differ diff --git a/lib/libthrift-0.8.0.jar b/lib/libthrift-0.8.0.jar new file mode 100644 index 000000000..98d8ffc03 Binary files /dev/null and b/lib/libthrift-0.8.0.jar differ diff --git a/lib/servlet-api.jar b/lib/servlet-api.jar new file mode 100644 index 000000000..1bf50af6e Binary files /dev/null and b/lib/servlet-api.jar differ diff --git a/lib/slf4j-api-1.5.8.jar b/lib/slf4j-api-1.5.8.jar new file mode 100644 index 000000000..20d1d3718 Binary files /dev/null and b/lib/slf4j-api-1.5.8.jar differ diff --git a/makejar.sh b/makejar.sh new file mode 100644 index 000000000..80c826f1d --- /dev/null +++ b/makejar.sh @@ -0,0 +1,4 @@ +cd bin/ +jar cvfM ../HippoAgent.jar ../src/META-INF/MANIFEST.MF ./* +cd .. +cp ./HippoAgent.jar /work/003_Hippo/091_Lib/ diff --git a/makethrift.sh b/makethrift.sh new file mode 100644 index 000000000..7dbedbae2 --- /dev/null +++ b/makethrift.sh @@ -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/ \ No newline at end of file diff --git a/manifest.txt b/manifest.txt new file mode 100644 index 000000000..c54710588 --- /dev/null +++ b/manifest.txt @@ -0,0 +1,2 @@ +Premain-Class: com.profiler.TomcatProfiler +Premain-Class: com.profiler.TomcatTracer \ No newline at end of file diff --git a/src/META-INF/MANIFEST.MF b/src/META-INF/MANIFEST.MF new file mode 100644 index 000000000..902ae8eac --- /dev/null +++ b/src/META-INF/MANIFEST.MF @@ -0,0 +1 @@ +Premain-Class: com.profiler.TomcatProfiler \ No newline at end of file diff --git a/src/com/profiler/TomcatProfiler.java b/src/com/profiler/TomcatProfiler.java new file mode 100644 index 000000000..0abd64150 --- /dev/null +++ b/src/com/profiler/TomcatProfiler.java @@ -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); + } +} diff --git a/src/com/profiler/TomcatTracer.java b/src/com/profiler/TomcatTracer.java new file mode 100644 index 000000000..1247cd1b7 --- /dev/null +++ b/src/com/profiler/TomcatTracer.java @@ -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; + } +} diff --git a/src/com/profiler/config/TomcatProfilerConfig.java b/src/com/profiler/config/TomcatProfilerConfig.java new file mode 100644 index 000000000..fa8a6a1e1 --- /dev/null +++ b/src/com/profiler/config/TomcatProfilerConfig.java @@ -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. #####"); + } +} diff --git a/src/com/profiler/config/TomcatProfilerConstant.java b/src/com/profiler/config/TomcatProfilerConstant.java new file mode 100644 index 000000000..bfd960d13 --- /dev/null +++ b/src/com/profiler/config/TomcatProfilerConstant.java @@ -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; +} diff --git a/src/com/profiler/dto/AgentInfoDTO.java b/src/com/profiler/dto/AgentInfoDTO.java new file mode 100644 index 000000000..7cca5599b --- /dev/null +++ b/src/com/profiler/dto/AgentInfoDTO.java @@ -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; + } +} diff --git a/src/com/profiler/dto/JVMInfoThriftDTO.java b/src/com/profiler/dto/JVMInfoThriftDTO.java new file mode 100644 index 000000000..2cb2b056a --- /dev/null +++ b/src/com/profiler/dto/JVMInfoThriftDTO.java @@ -0,0 +1,1421 @@ +/** + * 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 JVMInfoThriftDTO implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("JVMInfoThriftDTO"); + + private static final org.apache.thrift.protocol.TField AGENT_HASH_CODE_FIELD_DESC = new org.apache.thrift.protocol.TField("agentHashCode", org.apache.thrift.protocol.TType.I32, (short)1); + private static final org.apache.thrift.protocol.TField DATA_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("dataTime", org.apache.thrift.protocol.TType.I64, (short)2); + private static final org.apache.thrift.protocol.TField ACTIVE_THREAD_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("activeThreadCount", org.apache.thrift.protocol.TType.I32, (short)3); + private static final org.apache.thrift.protocol.TField GC1_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("gc1Count", org.apache.thrift.protocol.TType.I64, (short)4); + private static final org.apache.thrift.protocol.TField GC1_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("gc1Time", org.apache.thrift.protocol.TType.I64, (short)5); + private static final org.apache.thrift.protocol.TField GC2_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("gc2Count", org.apache.thrift.protocol.TType.I64, (short)6); + private static final org.apache.thrift.protocol.TField GC2_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("gc2Time", org.apache.thrift.protocol.TType.I64, (short)7); + private static final org.apache.thrift.protocol.TField HEAP_USED_FIELD_DESC = new org.apache.thrift.protocol.TField("heapUsed", org.apache.thrift.protocol.TType.I64, (short)8); + private static final org.apache.thrift.protocol.TField HEAP_COMMITTED_FIELD_DESC = new org.apache.thrift.protocol.TField("heapCommitted", org.apache.thrift.protocol.TType.I64, (short)9); + private static final org.apache.thrift.protocol.TField NON_HEAP_USED_FIELD_DESC = new org.apache.thrift.protocol.TField("nonHeapUsed", org.apache.thrift.protocol.TType.I64, (short)10); + private static final org.apache.thrift.protocol.TField NON_HEAP_COMMITTED_FIELD_DESC = new org.apache.thrift.protocol.TField("nonHeapCommitted", org.apache.thrift.protocol.TType.I64, (short)11); + private static final org.apache.thrift.protocol.TField PROCESS_CPUTIME_FIELD_DESC = new org.apache.thrift.protocol.TField("processCPUTime", org.apache.thrift.protocol.TType.DOUBLE, (short)12); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new JVMInfoThriftDTOStandardSchemeFactory()); + schemes.put(TupleScheme.class, new JVMInfoThriftDTOTupleSchemeFactory()); + } + + public int agentHashCode; // required + public long dataTime; // required + public int activeThreadCount; // required + public long gc1Count; // optional + public long gc1Time; // optional + public long gc2Count; // optional + public long gc2Time; // optional + public long heapUsed; // required + public long heapCommitted; // required + public long nonHeapUsed; // required + public long nonHeapCommitted; // required + public double processCPUTime; // optional + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + AGENT_HASH_CODE((short)1, "agentHashCode"), + DATA_TIME((short)2, "dataTime"), + ACTIVE_THREAD_COUNT((short)3, "activeThreadCount"), + GC1_COUNT((short)4, "gc1Count"), + GC1_TIME((short)5, "gc1Time"), + GC2_COUNT((short)6, "gc2Count"), + GC2_TIME((short)7, "gc2Time"), + HEAP_USED((short)8, "heapUsed"), + HEAP_COMMITTED((short)9, "heapCommitted"), + NON_HEAP_USED((short)10, "nonHeapUsed"), + NON_HEAP_COMMITTED((short)11, "nonHeapCommitted"), + PROCESS_CPUTIME((short)12, "processCPUTime"); + + private static final Map byName = new HashMap(); + + 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: // AGENT_HASH_CODE + return AGENT_HASH_CODE; + case 2: // DATA_TIME + return DATA_TIME; + case 3: // ACTIVE_THREAD_COUNT + return ACTIVE_THREAD_COUNT; + case 4: // GC1_COUNT + return GC1_COUNT; + case 5: // GC1_TIME + return GC1_TIME; + case 6: // GC2_COUNT + return GC2_COUNT; + case 7: // GC2_TIME + return GC2_TIME; + case 8: // HEAP_USED + return HEAP_USED; + case 9: // HEAP_COMMITTED + return HEAP_COMMITTED; + case 10: // NON_HEAP_USED + return NON_HEAP_USED; + case 11: // NON_HEAP_COMMITTED + return NON_HEAP_COMMITTED; + case 12: // PROCESS_CPUTIME + return PROCESS_CPUTIME; + 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 __AGENTHASHCODE_ISSET_ID = 0; + private static final int __DATATIME_ISSET_ID = 1; + private static final int __ACTIVETHREADCOUNT_ISSET_ID = 2; + private static final int __GC1COUNT_ISSET_ID = 3; + private static final int __GC1TIME_ISSET_ID = 4; + private static final int __GC2COUNT_ISSET_ID = 5; + private static final int __GC2TIME_ISSET_ID = 6; + private static final int __HEAPUSED_ISSET_ID = 7; + private static final int __HEAPCOMMITTED_ISSET_ID = 8; + private static final int __NONHEAPUSED_ISSET_ID = 9; + private static final int __NONHEAPCOMMITTED_ISSET_ID = 10; + private static final int __PROCESSCPUTIME_ISSET_ID = 11; + private BitSet __isset_bit_vector = new BitSet(12); + private _Fields optionals[] = {_Fields.GC1_COUNT,_Fields.GC1_TIME,_Fields.GC2_COUNT,_Fields.GC2_TIME,_Fields.PROCESS_CPUTIME}; + 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.AGENT_HASH_CODE, new org.apache.thrift.meta_data.FieldMetaData("agentHashCode", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.DATA_TIME, new org.apache.thrift.meta_data.FieldMetaData("dataTime", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.ACTIVE_THREAD_COUNT, new org.apache.thrift.meta_data.FieldMetaData("activeThreadCount", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.GC1_COUNT, new org.apache.thrift.meta_data.FieldMetaData("gc1Count", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.GC1_TIME, new org.apache.thrift.meta_data.FieldMetaData("gc1Time", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.GC2_COUNT, new org.apache.thrift.meta_data.FieldMetaData("gc2Count", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.GC2_TIME, new org.apache.thrift.meta_data.FieldMetaData("gc2Time", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.HEAP_USED, new org.apache.thrift.meta_data.FieldMetaData("heapUsed", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.HEAP_COMMITTED, new org.apache.thrift.meta_data.FieldMetaData("heapCommitted", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.NON_HEAP_USED, new org.apache.thrift.meta_data.FieldMetaData("nonHeapUsed", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.NON_HEAP_COMMITTED, new org.apache.thrift.meta_data.FieldMetaData("nonHeapCommitted", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.PROCESS_CPUTIME, new org.apache.thrift.meta_data.FieldMetaData("processCPUTime", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(JVMInfoThriftDTO.class, metaDataMap); + } + + public JVMInfoThriftDTO() { + } + + public JVMInfoThriftDTO( + int agentHashCode, + long dataTime, + int activeThreadCount, + long heapUsed, + long heapCommitted, + long nonHeapUsed, + long nonHeapCommitted) + { + this(); + this.agentHashCode = agentHashCode; + setAgentHashCodeIsSet(true); + this.dataTime = dataTime; + setDataTimeIsSet(true); + this.activeThreadCount = activeThreadCount; + setActiveThreadCountIsSet(true); + this.heapUsed = heapUsed; + setHeapUsedIsSet(true); + this.heapCommitted = heapCommitted; + setHeapCommittedIsSet(true); + this.nonHeapUsed = nonHeapUsed; + setNonHeapUsedIsSet(true); + this.nonHeapCommitted = nonHeapCommitted; + setNonHeapCommittedIsSet(true); + } + + /** + * Performs a deep copy on other. + */ + public JVMInfoThriftDTO(JVMInfoThriftDTO other) { + __isset_bit_vector.clear(); + __isset_bit_vector.or(other.__isset_bit_vector); + this.agentHashCode = other.agentHashCode; + this.dataTime = other.dataTime; + this.activeThreadCount = other.activeThreadCount; + this.gc1Count = other.gc1Count; + this.gc1Time = other.gc1Time; + this.gc2Count = other.gc2Count; + this.gc2Time = other.gc2Time; + this.heapUsed = other.heapUsed; + this.heapCommitted = other.heapCommitted; + this.nonHeapUsed = other.nonHeapUsed; + this.nonHeapCommitted = other.nonHeapCommitted; + this.processCPUTime = other.processCPUTime; + } + + public JVMInfoThriftDTO deepCopy() { + return new JVMInfoThriftDTO(this); + } + + @Override + public void clear() { + setAgentHashCodeIsSet(false); + this.agentHashCode = 0; + setDataTimeIsSet(false); + this.dataTime = 0; + setActiveThreadCountIsSet(false); + this.activeThreadCount = 0; + setGc1CountIsSet(false); + this.gc1Count = 0; + setGc1TimeIsSet(false); + this.gc1Time = 0; + setGc2CountIsSet(false); + this.gc2Count = 0; + setGc2TimeIsSet(false); + this.gc2Time = 0; + setHeapUsedIsSet(false); + this.heapUsed = 0; + setHeapCommittedIsSet(false); + this.heapCommitted = 0; + setNonHeapUsedIsSet(false); + this.nonHeapUsed = 0; + setNonHeapCommittedIsSet(false); + this.nonHeapCommitted = 0; + setProcessCPUTimeIsSet(false); + this.processCPUTime = 0.0; + } + + public int getAgentHashCode() { + return this.agentHashCode; + } + + public JVMInfoThriftDTO setAgentHashCode(int agentHashCode) { + this.agentHashCode = agentHashCode; + setAgentHashCodeIsSet(true); + return this; + } + + public void unsetAgentHashCode() { + __isset_bit_vector.clear(__AGENTHASHCODE_ISSET_ID); + } + + /** Returns true if field agentHashCode is set (has been assigned a value) and false otherwise */ + public boolean isSetAgentHashCode() { + return __isset_bit_vector.get(__AGENTHASHCODE_ISSET_ID); + } + + public void setAgentHashCodeIsSet(boolean value) { + __isset_bit_vector.set(__AGENTHASHCODE_ISSET_ID, value); + } + + public long getDataTime() { + return this.dataTime; + } + + public JVMInfoThriftDTO setDataTime(long dataTime) { + this.dataTime = dataTime; + setDataTimeIsSet(true); + return this; + } + + public void unsetDataTime() { + __isset_bit_vector.clear(__DATATIME_ISSET_ID); + } + + /** Returns true if field dataTime is set (has been assigned a value) and false otherwise */ + public boolean isSetDataTime() { + return __isset_bit_vector.get(__DATATIME_ISSET_ID); + } + + public void setDataTimeIsSet(boolean value) { + __isset_bit_vector.set(__DATATIME_ISSET_ID, value); + } + + public int getActiveThreadCount() { + return this.activeThreadCount; + } + + public JVMInfoThriftDTO setActiveThreadCount(int activeThreadCount) { + this.activeThreadCount = activeThreadCount; + setActiveThreadCountIsSet(true); + return this; + } + + public void unsetActiveThreadCount() { + __isset_bit_vector.clear(__ACTIVETHREADCOUNT_ISSET_ID); + } + + /** Returns true if field activeThreadCount is set (has been assigned a value) and false otherwise */ + public boolean isSetActiveThreadCount() { + return __isset_bit_vector.get(__ACTIVETHREADCOUNT_ISSET_ID); + } + + public void setActiveThreadCountIsSet(boolean value) { + __isset_bit_vector.set(__ACTIVETHREADCOUNT_ISSET_ID, value); + } + + public long getGc1Count() { + return this.gc1Count; + } + + public JVMInfoThriftDTO setGc1Count(long gc1Count) { + this.gc1Count = gc1Count; + setGc1CountIsSet(true); + return this; + } + + public void unsetGc1Count() { + __isset_bit_vector.clear(__GC1COUNT_ISSET_ID); + } + + /** Returns true if field gc1Count is set (has been assigned a value) and false otherwise */ + public boolean isSetGc1Count() { + return __isset_bit_vector.get(__GC1COUNT_ISSET_ID); + } + + public void setGc1CountIsSet(boolean value) { + __isset_bit_vector.set(__GC1COUNT_ISSET_ID, value); + } + + public long getGc1Time() { + return this.gc1Time; + } + + public JVMInfoThriftDTO setGc1Time(long gc1Time) { + this.gc1Time = gc1Time; + setGc1TimeIsSet(true); + return this; + } + + public void unsetGc1Time() { + __isset_bit_vector.clear(__GC1TIME_ISSET_ID); + } + + /** Returns true if field gc1Time is set (has been assigned a value) and false otherwise */ + public boolean isSetGc1Time() { + return __isset_bit_vector.get(__GC1TIME_ISSET_ID); + } + + public void setGc1TimeIsSet(boolean value) { + __isset_bit_vector.set(__GC1TIME_ISSET_ID, value); + } + + public long getGc2Count() { + return this.gc2Count; + } + + public JVMInfoThriftDTO setGc2Count(long gc2Count) { + this.gc2Count = gc2Count; + setGc2CountIsSet(true); + return this; + } + + public void unsetGc2Count() { + __isset_bit_vector.clear(__GC2COUNT_ISSET_ID); + } + + /** Returns true if field gc2Count is set (has been assigned a value) and false otherwise */ + public boolean isSetGc2Count() { + return __isset_bit_vector.get(__GC2COUNT_ISSET_ID); + } + + public void setGc2CountIsSet(boolean value) { + __isset_bit_vector.set(__GC2COUNT_ISSET_ID, value); + } + + public long getGc2Time() { + return this.gc2Time; + } + + public JVMInfoThriftDTO setGc2Time(long gc2Time) { + this.gc2Time = gc2Time; + setGc2TimeIsSet(true); + return this; + } + + public void unsetGc2Time() { + __isset_bit_vector.clear(__GC2TIME_ISSET_ID); + } + + /** Returns true if field gc2Time is set (has been assigned a value) and false otherwise */ + public boolean isSetGc2Time() { + return __isset_bit_vector.get(__GC2TIME_ISSET_ID); + } + + public void setGc2TimeIsSet(boolean value) { + __isset_bit_vector.set(__GC2TIME_ISSET_ID, value); + } + + public long getHeapUsed() { + return this.heapUsed; + } + + public JVMInfoThriftDTO setHeapUsed(long heapUsed) { + this.heapUsed = heapUsed; + setHeapUsedIsSet(true); + return this; + } + + public void unsetHeapUsed() { + __isset_bit_vector.clear(__HEAPUSED_ISSET_ID); + } + + /** Returns true if field heapUsed is set (has been assigned a value) and false otherwise */ + public boolean isSetHeapUsed() { + return __isset_bit_vector.get(__HEAPUSED_ISSET_ID); + } + + public void setHeapUsedIsSet(boolean value) { + __isset_bit_vector.set(__HEAPUSED_ISSET_ID, value); + } + + public long getHeapCommitted() { + return this.heapCommitted; + } + + public JVMInfoThriftDTO setHeapCommitted(long heapCommitted) { + this.heapCommitted = heapCommitted; + setHeapCommittedIsSet(true); + return this; + } + + public void unsetHeapCommitted() { + __isset_bit_vector.clear(__HEAPCOMMITTED_ISSET_ID); + } + + /** Returns true if field heapCommitted is set (has been assigned a value) and false otherwise */ + public boolean isSetHeapCommitted() { + return __isset_bit_vector.get(__HEAPCOMMITTED_ISSET_ID); + } + + public void setHeapCommittedIsSet(boolean value) { + __isset_bit_vector.set(__HEAPCOMMITTED_ISSET_ID, value); + } + + public long getNonHeapUsed() { + return this.nonHeapUsed; + } + + public JVMInfoThriftDTO setNonHeapUsed(long nonHeapUsed) { + this.nonHeapUsed = nonHeapUsed; + setNonHeapUsedIsSet(true); + return this; + } + + public void unsetNonHeapUsed() { + __isset_bit_vector.clear(__NONHEAPUSED_ISSET_ID); + } + + /** Returns true if field nonHeapUsed is set (has been assigned a value) and false otherwise */ + public boolean isSetNonHeapUsed() { + return __isset_bit_vector.get(__NONHEAPUSED_ISSET_ID); + } + + public void setNonHeapUsedIsSet(boolean value) { + __isset_bit_vector.set(__NONHEAPUSED_ISSET_ID, value); + } + + public long getNonHeapCommitted() { + return this.nonHeapCommitted; + } + + public JVMInfoThriftDTO setNonHeapCommitted(long nonHeapCommitted) { + this.nonHeapCommitted = nonHeapCommitted; + setNonHeapCommittedIsSet(true); + return this; + } + + public void unsetNonHeapCommitted() { + __isset_bit_vector.clear(__NONHEAPCOMMITTED_ISSET_ID); + } + + /** Returns true if field nonHeapCommitted is set (has been assigned a value) and false otherwise */ + public boolean isSetNonHeapCommitted() { + return __isset_bit_vector.get(__NONHEAPCOMMITTED_ISSET_ID); + } + + public void setNonHeapCommittedIsSet(boolean value) { + __isset_bit_vector.set(__NONHEAPCOMMITTED_ISSET_ID, value); + } + + public double getProcessCPUTime() { + return this.processCPUTime; + } + + public JVMInfoThriftDTO setProcessCPUTime(double processCPUTime) { + this.processCPUTime = processCPUTime; + setProcessCPUTimeIsSet(true); + return this; + } + + public void unsetProcessCPUTime() { + __isset_bit_vector.clear(__PROCESSCPUTIME_ISSET_ID); + } + + /** Returns true if field processCPUTime is set (has been assigned a value) and false otherwise */ + public boolean isSetProcessCPUTime() { + return __isset_bit_vector.get(__PROCESSCPUTIME_ISSET_ID); + } + + public void setProcessCPUTimeIsSet(boolean value) { + __isset_bit_vector.set(__PROCESSCPUTIME_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case AGENT_HASH_CODE: + if (value == null) { + unsetAgentHashCode(); + } else { + setAgentHashCode((Integer)value); + } + break; + + case DATA_TIME: + if (value == null) { + unsetDataTime(); + } else { + setDataTime((Long)value); + } + break; + + case ACTIVE_THREAD_COUNT: + if (value == null) { + unsetActiveThreadCount(); + } else { + setActiveThreadCount((Integer)value); + } + break; + + case GC1_COUNT: + if (value == null) { + unsetGc1Count(); + } else { + setGc1Count((Long)value); + } + break; + + case GC1_TIME: + if (value == null) { + unsetGc1Time(); + } else { + setGc1Time((Long)value); + } + break; + + case GC2_COUNT: + if (value == null) { + unsetGc2Count(); + } else { + setGc2Count((Long)value); + } + break; + + case GC2_TIME: + if (value == null) { + unsetGc2Time(); + } else { + setGc2Time((Long)value); + } + break; + + case HEAP_USED: + if (value == null) { + unsetHeapUsed(); + } else { + setHeapUsed((Long)value); + } + break; + + case HEAP_COMMITTED: + if (value == null) { + unsetHeapCommitted(); + } else { + setHeapCommitted((Long)value); + } + break; + + case NON_HEAP_USED: + if (value == null) { + unsetNonHeapUsed(); + } else { + setNonHeapUsed((Long)value); + } + break; + + case NON_HEAP_COMMITTED: + if (value == null) { + unsetNonHeapCommitted(); + } else { + setNonHeapCommitted((Long)value); + } + break; + + case PROCESS_CPUTIME: + if (value == null) { + unsetProcessCPUTime(); + } else { + setProcessCPUTime((Double)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case AGENT_HASH_CODE: + return Integer.valueOf(getAgentHashCode()); + + case DATA_TIME: + return Long.valueOf(getDataTime()); + + case ACTIVE_THREAD_COUNT: + return Integer.valueOf(getActiveThreadCount()); + + case GC1_COUNT: + return Long.valueOf(getGc1Count()); + + case GC1_TIME: + return Long.valueOf(getGc1Time()); + + case GC2_COUNT: + return Long.valueOf(getGc2Count()); + + case GC2_TIME: + return Long.valueOf(getGc2Time()); + + case HEAP_USED: + return Long.valueOf(getHeapUsed()); + + case HEAP_COMMITTED: + return Long.valueOf(getHeapCommitted()); + + case NON_HEAP_USED: + return Long.valueOf(getNonHeapUsed()); + + case NON_HEAP_COMMITTED: + return Long.valueOf(getNonHeapCommitted()); + + case PROCESS_CPUTIME: + return Double.valueOf(getProcessCPUTime()); + + } + 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 AGENT_HASH_CODE: + return isSetAgentHashCode(); + case DATA_TIME: + return isSetDataTime(); + case ACTIVE_THREAD_COUNT: + return isSetActiveThreadCount(); + case GC1_COUNT: + return isSetGc1Count(); + case GC1_TIME: + return isSetGc1Time(); + case GC2_COUNT: + return isSetGc2Count(); + case GC2_TIME: + return isSetGc2Time(); + case HEAP_USED: + return isSetHeapUsed(); + case HEAP_COMMITTED: + return isSetHeapCommitted(); + case NON_HEAP_USED: + return isSetNonHeapUsed(); + case NON_HEAP_COMMITTED: + return isSetNonHeapCommitted(); + case PROCESS_CPUTIME: + return isSetProcessCPUTime(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof JVMInfoThriftDTO) + return this.equals((JVMInfoThriftDTO)that); + return false; + } + + public boolean equals(JVMInfoThriftDTO that) { + if (that == null) + return false; + + boolean this_present_agentHashCode = true; + boolean that_present_agentHashCode = true; + if (this_present_agentHashCode || that_present_agentHashCode) { + if (!(this_present_agentHashCode && that_present_agentHashCode)) + return false; + if (this.agentHashCode != that.agentHashCode) + return false; + } + + boolean this_present_dataTime = true; + boolean that_present_dataTime = true; + if (this_present_dataTime || that_present_dataTime) { + if (!(this_present_dataTime && that_present_dataTime)) + return false; + if (this.dataTime != that.dataTime) + return false; + } + + boolean this_present_activeThreadCount = true; + boolean that_present_activeThreadCount = true; + if (this_present_activeThreadCount || that_present_activeThreadCount) { + if (!(this_present_activeThreadCount && that_present_activeThreadCount)) + return false; + if (this.activeThreadCount != that.activeThreadCount) + return false; + } + + boolean this_present_gc1Count = true && this.isSetGc1Count(); + boolean that_present_gc1Count = true && that.isSetGc1Count(); + if (this_present_gc1Count || that_present_gc1Count) { + if (!(this_present_gc1Count && that_present_gc1Count)) + return false; + if (this.gc1Count != that.gc1Count) + return false; + } + + boolean this_present_gc1Time = true && this.isSetGc1Time(); + boolean that_present_gc1Time = true && that.isSetGc1Time(); + if (this_present_gc1Time || that_present_gc1Time) { + if (!(this_present_gc1Time && that_present_gc1Time)) + return false; + if (this.gc1Time != that.gc1Time) + return false; + } + + boolean this_present_gc2Count = true && this.isSetGc2Count(); + boolean that_present_gc2Count = true && that.isSetGc2Count(); + if (this_present_gc2Count || that_present_gc2Count) { + if (!(this_present_gc2Count && that_present_gc2Count)) + return false; + if (this.gc2Count != that.gc2Count) + return false; + } + + boolean this_present_gc2Time = true && this.isSetGc2Time(); + boolean that_present_gc2Time = true && that.isSetGc2Time(); + if (this_present_gc2Time || that_present_gc2Time) { + if (!(this_present_gc2Time && that_present_gc2Time)) + return false; + if (this.gc2Time != that.gc2Time) + return false; + } + + boolean this_present_heapUsed = true; + boolean that_present_heapUsed = true; + if (this_present_heapUsed || that_present_heapUsed) { + if (!(this_present_heapUsed && that_present_heapUsed)) + return false; + if (this.heapUsed != that.heapUsed) + return false; + } + + boolean this_present_heapCommitted = true; + boolean that_present_heapCommitted = true; + if (this_present_heapCommitted || that_present_heapCommitted) { + if (!(this_present_heapCommitted && that_present_heapCommitted)) + return false; + if (this.heapCommitted != that.heapCommitted) + return false; + } + + boolean this_present_nonHeapUsed = true; + boolean that_present_nonHeapUsed = true; + if (this_present_nonHeapUsed || that_present_nonHeapUsed) { + if (!(this_present_nonHeapUsed && that_present_nonHeapUsed)) + return false; + if (this.nonHeapUsed != that.nonHeapUsed) + return false; + } + + boolean this_present_nonHeapCommitted = true; + boolean that_present_nonHeapCommitted = true; + if (this_present_nonHeapCommitted || that_present_nonHeapCommitted) { + if (!(this_present_nonHeapCommitted && that_present_nonHeapCommitted)) + return false; + if (this.nonHeapCommitted != that.nonHeapCommitted) + return false; + } + + boolean this_present_processCPUTime = true && this.isSetProcessCPUTime(); + boolean that_present_processCPUTime = true && that.isSetProcessCPUTime(); + if (this_present_processCPUTime || that_present_processCPUTime) { + if (!(this_present_processCPUTime && that_present_processCPUTime)) + return false; + if (this.processCPUTime != that.processCPUTime) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(JVMInfoThriftDTO other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + JVMInfoThriftDTO typedOther = (JVMInfoThriftDTO)other; + + lastComparison = Boolean.valueOf(isSetAgentHashCode()).compareTo(typedOther.isSetAgentHashCode()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetAgentHashCode()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.agentHashCode, typedOther.agentHashCode); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDataTime()).compareTo(typedOther.isSetDataTime()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDataTime()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dataTime, typedOther.dataTime); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetActiveThreadCount()).compareTo(typedOther.isSetActiveThreadCount()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetActiveThreadCount()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.activeThreadCount, typedOther.activeThreadCount); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetGc1Count()).compareTo(typedOther.isSetGc1Count()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetGc1Count()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.gc1Count, typedOther.gc1Count); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetGc1Time()).compareTo(typedOther.isSetGc1Time()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetGc1Time()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.gc1Time, typedOther.gc1Time); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetGc2Count()).compareTo(typedOther.isSetGc2Count()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetGc2Count()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.gc2Count, typedOther.gc2Count); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetGc2Time()).compareTo(typedOther.isSetGc2Time()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetGc2Time()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.gc2Time, typedOther.gc2Time); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetHeapUsed()).compareTo(typedOther.isSetHeapUsed()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetHeapUsed()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.heapUsed, typedOther.heapUsed); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetHeapCommitted()).compareTo(typedOther.isSetHeapCommitted()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetHeapCommitted()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.heapCommitted, typedOther.heapCommitted); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetNonHeapUsed()).compareTo(typedOther.isSetNonHeapUsed()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetNonHeapUsed()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nonHeapUsed, typedOther.nonHeapUsed); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetNonHeapCommitted()).compareTo(typedOther.isSetNonHeapCommitted()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetNonHeapCommitted()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nonHeapCommitted, typedOther.nonHeapCommitted); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetProcessCPUTime()).compareTo(typedOther.isSetProcessCPUTime()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetProcessCPUTime()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.processCPUTime, typedOther.processCPUTime); + 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("JVMInfoThriftDTO("); + boolean first = true; + + sb.append("agentHashCode:"); + sb.append(this.agentHashCode); + first = false; + if (!first) sb.append(", "); + sb.append("dataTime:"); + sb.append(this.dataTime); + first = false; + if (!first) sb.append(", "); + sb.append("activeThreadCount:"); + sb.append(this.activeThreadCount); + first = false; + if (isSetGc1Count()) { + if (!first) sb.append(", "); + sb.append("gc1Count:"); + sb.append(this.gc1Count); + first = false; + } + if (isSetGc1Time()) { + if (!first) sb.append(", "); + sb.append("gc1Time:"); + sb.append(this.gc1Time); + first = false; + } + if (isSetGc2Count()) { + if (!first) sb.append(", "); + sb.append("gc2Count:"); + sb.append(this.gc2Count); + first = false; + } + if (isSetGc2Time()) { + if (!first) sb.append(", "); + sb.append("gc2Time:"); + sb.append(this.gc2Time); + first = false; + } + if (!first) sb.append(", "); + sb.append("heapUsed:"); + sb.append(this.heapUsed); + first = false; + if (!first) sb.append(", "); + sb.append("heapCommitted:"); + sb.append(this.heapCommitted); + first = false; + if (!first) sb.append(", "); + sb.append("nonHeapUsed:"); + sb.append(this.nonHeapUsed); + first = false; + if (!first) sb.append(", "); + sb.append("nonHeapCommitted:"); + sb.append(this.nonHeapCommitted); + first = false; + if (isSetProcessCPUTime()) { + if (!first) sb.append(", "); + sb.append("processCPUTime:"); + sb.append(this.processCPUTime); + 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 JVMInfoThriftDTOStandardSchemeFactory implements SchemeFactory { + public JVMInfoThriftDTOStandardScheme getScheme() { + return new JVMInfoThriftDTOStandardScheme(); + } + } + + private static class JVMInfoThriftDTOStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, JVMInfoThriftDTO 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: // AGENT_HASH_CODE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.agentHashCode = iprot.readI32(); + struct.setAgentHashCodeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // DATA_TIME + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.dataTime = iprot.readI64(); + struct.setDataTimeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // ACTIVE_THREAD_COUNT + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.activeThreadCount = iprot.readI32(); + struct.setActiveThreadCountIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // GC1_COUNT + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.gc1Count = iprot.readI64(); + struct.setGc1CountIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // GC1_TIME + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.gc1Time = iprot.readI64(); + struct.setGc1TimeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 6: // GC2_COUNT + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.gc2Count = iprot.readI64(); + struct.setGc2CountIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 7: // GC2_TIME + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.gc2Time = iprot.readI64(); + struct.setGc2TimeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 8: // HEAP_USED + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.heapUsed = iprot.readI64(); + struct.setHeapUsedIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 9: // HEAP_COMMITTED + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.heapCommitted = iprot.readI64(); + struct.setHeapCommittedIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 10: // NON_HEAP_USED + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.nonHeapUsed = iprot.readI64(); + struct.setNonHeapUsedIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 11: // NON_HEAP_COMMITTED + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.nonHeapCommitted = iprot.readI64(); + struct.setNonHeapCommittedIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 12: // PROCESS_CPUTIME + if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) { + struct.processCPUTime = iprot.readDouble(); + struct.setProcessCPUTimeIsSet(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, JVMInfoThriftDTO struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(AGENT_HASH_CODE_FIELD_DESC); + oprot.writeI32(struct.agentHashCode); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(DATA_TIME_FIELD_DESC); + oprot.writeI64(struct.dataTime); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(ACTIVE_THREAD_COUNT_FIELD_DESC); + oprot.writeI32(struct.activeThreadCount); + oprot.writeFieldEnd(); + if (struct.isSetGc1Count()) { + oprot.writeFieldBegin(GC1_COUNT_FIELD_DESC); + oprot.writeI64(struct.gc1Count); + oprot.writeFieldEnd(); + } + if (struct.isSetGc1Time()) { + oprot.writeFieldBegin(GC1_TIME_FIELD_DESC); + oprot.writeI64(struct.gc1Time); + oprot.writeFieldEnd(); + } + if (struct.isSetGc2Count()) { + oprot.writeFieldBegin(GC2_COUNT_FIELD_DESC); + oprot.writeI64(struct.gc2Count); + oprot.writeFieldEnd(); + } + if (struct.isSetGc2Time()) { + oprot.writeFieldBegin(GC2_TIME_FIELD_DESC); + oprot.writeI64(struct.gc2Time); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(HEAP_USED_FIELD_DESC); + oprot.writeI64(struct.heapUsed); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(HEAP_COMMITTED_FIELD_DESC); + oprot.writeI64(struct.heapCommitted); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(NON_HEAP_USED_FIELD_DESC); + oprot.writeI64(struct.nonHeapUsed); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(NON_HEAP_COMMITTED_FIELD_DESC); + oprot.writeI64(struct.nonHeapCommitted); + oprot.writeFieldEnd(); + if (struct.isSetProcessCPUTime()) { + oprot.writeFieldBegin(PROCESS_CPUTIME_FIELD_DESC); + oprot.writeDouble(struct.processCPUTime); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class JVMInfoThriftDTOTupleSchemeFactory implements SchemeFactory { + public JVMInfoThriftDTOTupleScheme getScheme() { + return new JVMInfoThriftDTOTupleScheme(); + } + } + + private static class JVMInfoThriftDTOTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, JVMInfoThriftDTO struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetAgentHashCode()) { + optionals.set(0); + } + if (struct.isSetDataTime()) { + optionals.set(1); + } + if (struct.isSetActiveThreadCount()) { + optionals.set(2); + } + if (struct.isSetGc1Count()) { + optionals.set(3); + } + if (struct.isSetGc1Time()) { + optionals.set(4); + } + if (struct.isSetGc2Count()) { + optionals.set(5); + } + if (struct.isSetGc2Time()) { + optionals.set(6); + } + if (struct.isSetHeapUsed()) { + optionals.set(7); + } + if (struct.isSetHeapCommitted()) { + optionals.set(8); + } + if (struct.isSetNonHeapUsed()) { + optionals.set(9); + } + if (struct.isSetNonHeapCommitted()) { + optionals.set(10); + } + if (struct.isSetProcessCPUTime()) { + optionals.set(11); + } + oprot.writeBitSet(optionals, 12); + if (struct.isSetAgentHashCode()) { + oprot.writeI32(struct.agentHashCode); + } + if (struct.isSetDataTime()) { + oprot.writeI64(struct.dataTime); + } + if (struct.isSetActiveThreadCount()) { + oprot.writeI32(struct.activeThreadCount); + } + if (struct.isSetGc1Count()) { + oprot.writeI64(struct.gc1Count); + } + if (struct.isSetGc1Time()) { + oprot.writeI64(struct.gc1Time); + } + if (struct.isSetGc2Count()) { + oprot.writeI64(struct.gc2Count); + } + if (struct.isSetGc2Time()) { + oprot.writeI64(struct.gc2Time); + } + if (struct.isSetHeapUsed()) { + oprot.writeI64(struct.heapUsed); + } + if (struct.isSetHeapCommitted()) { + oprot.writeI64(struct.heapCommitted); + } + if (struct.isSetNonHeapUsed()) { + oprot.writeI64(struct.nonHeapUsed); + } + if (struct.isSetNonHeapCommitted()) { + oprot.writeI64(struct.nonHeapCommitted); + } + if (struct.isSetProcessCPUTime()) { + oprot.writeDouble(struct.processCPUTime); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, JVMInfoThriftDTO struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(12); + if (incoming.get(0)) { + struct.agentHashCode = iprot.readI32(); + struct.setAgentHashCodeIsSet(true); + } + if (incoming.get(1)) { + struct.dataTime = iprot.readI64(); + struct.setDataTimeIsSet(true); + } + if (incoming.get(2)) { + struct.activeThreadCount = iprot.readI32(); + struct.setActiveThreadCountIsSet(true); + } + if (incoming.get(3)) { + struct.gc1Count = iprot.readI64(); + struct.setGc1CountIsSet(true); + } + if (incoming.get(4)) { + struct.gc1Time = iprot.readI64(); + struct.setGc1TimeIsSet(true); + } + if (incoming.get(5)) { + struct.gc2Count = iprot.readI64(); + struct.setGc2CountIsSet(true); + } + if (incoming.get(6)) { + struct.gc2Time = iprot.readI64(); + struct.setGc2TimeIsSet(true); + } + if (incoming.get(7)) { + struct.heapUsed = iprot.readI64(); + struct.setHeapUsedIsSet(true); + } + if (incoming.get(8)) { + struct.heapCommitted = iprot.readI64(); + struct.setHeapCommittedIsSet(true); + } + if (incoming.get(9)) { + struct.nonHeapUsed = iprot.readI64(); + struct.setNonHeapUsedIsSet(true); + } + if (incoming.get(10)) { + struct.nonHeapCommitted = iprot.readI64(); + struct.setNonHeapCommittedIsSet(true); + } + if (incoming.get(11)) { + struct.processCPUTime = iprot.readDouble(); + struct.setProcessCPUTimeIsSet(true); + } + } + } + +} + diff --git a/src/com/profiler/dto/RequestDataListThriftDTO.java b/src/com/profiler/dto/RequestDataListThriftDTO.java new file mode 100644 index 000000000..bde4cf592 --- /dev/null +++ b/src/com/profiler/dto/RequestDataListThriftDTO.java @@ -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, 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, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new RequestDataListThriftDTOStandardSchemeFactory()); + schemes.put(TupleScheme.class, new RequestDataListThriftDTOTupleSchemeFactory()); + } + + public int hostHashCode; // required + public int requestHashCode; // required + public List 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 byName = new HashMap(); + + 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 requestDataList) + { + this(); + this.hostHashCode = hostHashCode; + setHostHashCodeIsSet(true); + this.requestHashCode = requestHashCode; + setRequestHashCodeIsSet(true); + this.requestDataList = requestDataList; + } + + /** + * Performs a deep copy on other. + */ + 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 __this__requestDataList = new ArrayList(); + 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 getRequestDataListIterator() { + return (this.requestDataList == null) ? null : this.requestDataList.iterator(); + } + + public void addToRequestDataList(RequestDataThriftDTO elem) { + if (this.requestDataList == null) { + this.requestDataList = new ArrayList(); + } + this.requestDataList.add(elem); + } + + public List getRequestDataList() { + return this.requestDataList; + } + + public RequestDataListThriftDTO setRequestDataList(List 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)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 { + + 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(_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 { + + @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(_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); + } + } + } + +} + diff --git a/src/com/profiler/dto/RequestDataThriftDTO.java b/src/com/profiler/dto/RequestDataThriftDTO.java new file mode 100644 index 000000000..67dd33c07 --- /dev/null +++ b/src/com/profiler/dto/RequestDataThriftDTO.java @@ -0,0 +1,1549 @@ +/** + * 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 RequestDataThriftDTO implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RequestDataThriftDTO"); + + private static final org.apache.thrift.protocol.TField DATA_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("dataType", org.apache.thrift.protocol.TType.I32, (short)1); + private static final org.apache.thrift.protocol.TField DATA_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("dataTime", org.apache.thrift.protocol.TType.I64, (short)2); + private static final org.apache.thrift.protocol.TField DATA_HASH_CODE_FIELD_DESC = new org.apache.thrift.protocol.TField("dataHashCode", org.apache.thrift.protocol.TType.I32, (short)3); + private static final org.apache.thrift.protocol.TField DATA_STRING_FIELD_DESC = new org.apache.thrift.protocol.TField("dataString", org.apache.thrift.protocol.TType.STRING, (short)4); + private static final org.apache.thrift.protocol.TField EXTRA_DATA1_FIELD_DESC = new org.apache.thrift.protocol.TField("extraData1", org.apache.thrift.protocol.TType.STRING, (short)5); + private static final org.apache.thrift.protocol.TField EXTRA_DATA2_FIELD_DESC = new org.apache.thrift.protocol.TField("extraData2", org.apache.thrift.protocol.TType.STRING, (short)6); + private static final org.apache.thrift.protocol.TField EXTRA_DATA3_FIELD_DESC = new org.apache.thrift.protocol.TField("extraData3", org.apache.thrift.protocol.TType.STRING, (short)7); + private static final org.apache.thrift.protocol.TField EXTRA_INT1_FIELD_DESC = new org.apache.thrift.protocol.TField("extraInt1", org.apache.thrift.protocol.TType.I32, (short)8); + private static final org.apache.thrift.protocol.TField EXTRA_INT2_FIELD_DESC = new org.apache.thrift.protocol.TField("extraInt2", org.apache.thrift.protocol.TType.I32, (short)9); + private static final org.apache.thrift.protocol.TField EXTRA_INT3_FIELD_DESC = new org.apache.thrift.protocol.TField("extraInt3", org.apache.thrift.protocol.TType.I32, (short)10); + private static final org.apache.thrift.protocol.TField EXTRA_LONG1_FIELD_DESC = new org.apache.thrift.protocol.TField("extraLong1", org.apache.thrift.protocol.TType.I64, (short)11); + private static final org.apache.thrift.protocol.TField EXTRA_LONG2_FIELD_DESC = new org.apache.thrift.protocol.TField("extraLong2", org.apache.thrift.protocol.TType.I64, (short)12); + private static final org.apache.thrift.protocol.TField EXTRA_LONG3_FIELD_DESC = new org.apache.thrift.protocol.TField("extraLong3", org.apache.thrift.protocol.TType.I64, (short)13); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new RequestDataThriftDTOStandardSchemeFactory()); + schemes.put(TupleScheme.class, new RequestDataThriftDTOTupleSchemeFactory()); + } + + public int dataType; // required + public long dataTime; // required + public int dataHashCode; // optional + public String dataString; // optional + public String extraData1; // optional + public String extraData2; // optional + public String extraData3; // optional + public int extraInt1; // optional + public int extraInt2; // optional + public int extraInt3; // optional + public long extraLong1; // optional + public long extraLong2; // optional + public long extraLong3; // optional + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + DATA_TYPE((short)1, "dataType"), + DATA_TIME((short)2, "dataTime"), + DATA_HASH_CODE((short)3, "dataHashCode"), + DATA_STRING((short)4, "dataString"), + EXTRA_DATA1((short)5, "extraData1"), + EXTRA_DATA2((short)6, "extraData2"), + EXTRA_DATA3((short)7, "extraData3"), + EXTRA_INT1((short)8, "extraInt1"), + EXTRA_INT2((short)9, "extraInt2"), + EXTRA_INT3((short)10, "extraInt3"), + EXTRA_LONG1((short)11, "extraLong1"), + EXTRA_LONG2((short)12, "extraLong2"), + EXTRA_LONG3((short)13, "extraLong3"); + + private static final Map byName = new HashMap(); + + 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: // DATA_TYPE + return DATA_TYPE; + case 2: // DATA_TIME + return DATA_TIME; + case 3: // DATA_HASH_CODE + return DATA_HASH_CODE; + case 4: // DATA_STRING + return DATA_STRING; + case 5: // EXTRA_DATA1 + return EXTRA_DATA1; + case 6: // EXTRA_DATA2 + return EXTRA_DATA2; + case 7: // EXTRA_DATA3 + return EXTRA_DATA3; + case 8: // EXTRA_INT1 + return EXTRA_INT1; + case 9: // EXTRA_INT2 + return EXTRA_INT2; + case 10: // EXTRA_INT3 + return EXTRA_INT3; + case 11: // EXTRA_LONG1 + return EXTRA_LONG1; + case 12: // EXTRA_LONG2 + return EXTRA_LONG2; + case 13: // EXTRA_LONG3 + return EXTRA_LONG3; + 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 __DATATYPE_ISSET_ID = 0; + private static final int __DATATIME_ISSET_ID = 1; + private static final int __DATAHASHCODE_ISSET_ID = 2; + private static final int __EXTRAINT1_ISSET_ID = 3; + private static final int __EXTRAINT2_ISSET_ID = 4; + private static final int __EXTRAINT3_ISSET_ID = 5; + private static final int __EXTRALONG1_ISSET_ID = 6; + private static final int __EXTRALONG2_ISSET_ID = 7; + private static final int __EXTRALONG3_ISSET_ID = 8; + private BitSet __isset_bit_vector = new BitSet(9); + private _Fields optionals[] = {_Fields.DATA_HASH_CODE,_Fields.DATA_STRING,_Fields.EXTRA_DATA1,_Fields.EXTRA_DATA2,_Fields.EXTRA_DATA3,_Fields.EXTRA_INT1,_Fields.EXTRA_INT2,_Fields.EXTRA_INT3,_Fields.EXTRA_LONG1,_Fields.EXTRA_LONG2,_Fields.EXTRA_LONG3}; + 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.DATA_TYPE, new org.apache.thrift.meta_data.FieldMetaData("dataType", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.DATA_TIME, new org.apache.thrift.meta_data.FieldMetaData("dataTime", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.DATA_HASH_CODE, new org.apache.thrift.meta_data.FieldMetaData("dataHashCode", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.DATA_STRING, new org.apache.thrift.meta_data.FieldMetaData("dataString", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.EXTRA_DATA1, new org.apache.thrift.meta_data.FieldMetaData("extraData1", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.EXTRA_DATA2, new org.apache.thrift.meta_data.FieldMetaData("extraData2", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.EXTRA_DATA3, new org.apache.thrift.meta_data.FieldMetaData("extraData3", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.EXTRA_INT1, new org.apache.thrift.meta_data.FieldMetaData("extraInt1", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.EXTRA_INT2, new org.apache.thrift.meta_data.FieldMetaData("extraInt2", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.EXTRA_INT3, new org.apache.thrift.meta_data.FieldMetaData("extraInt3", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.EXTRA_LONG1, new org.apache.thrift.meta_data.FieldMetaData("extraLong1", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.EXTRA_LONG2, new org.apache.thrift.meta_data.FieldMetaData("extraLong2", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.EXTRA_LONG3, new org.apache.thrift.meta_data.FieldMetaData("extraLong3", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(RequestDataThriftDTO.class, metaDataMap); + } + + public RequestDataThriftDTO() { + } + + public RequestDataThriftDTO( + int dataType, + long dataTime) + { + this(); + this.dataType = dataType; + setDataTypeIsSet(true); + this.dataTime = dataTime; + setDataTimeIsSet(true); + } + + /** + * Performs a deep copy on other. + */ + public RequestDataThriftDTO(RequestDataThriftDTO other) { + __isset_bit_vector.clear(); + __isset_bit_vector.or(other.__isset_bit_vector); + this.dataType = other.dataType; + this.dataTime = other.dataTime; + this.dataHashCode = other.dataHashCode; + if (other.isSetDataString()) { + this.dataString = other.dataString; + } + if (other.isSetExtraData1()) { + this.extraData1 = other.extraData1; + } + if (other.isSetExtraData2()) { + this.extraData2 = other.extraData2; + } + if (other.isSetExtraData3()) { + this.extraData3 = other.extraData3; + } + this.extraInt1 = other.extraInt1; + this.extraInt2 = other.extraInt2; + this.extraInt3 = other.extraInt3; + this.extraLong1 = other.extraLong1; + this.extraLong2 = other.extraLong2; + this.extraLong3 = other.extraLong3; + } + + public RequestDataThriftDTO deepCopy() { + return new RequestDataThriftDTO(this); + } + + @Override + public void clear() { + setDataTypeIsSet(false); + this.dataType = 0; + setDataTimeIsSet(false); + this.dataTime = 0; + setDataHashCodeIsSet(false); + this.dataHashCode = 0; + this.dataString = null; + this.extraData1 = null; + this.extraData2 = null; + this.extraData3 = null; + setExtraInt1IsSet(false); + this.extraInt1 = 0; + setExtraInt2IsSet(false); + this.extraInt2 = 0; + setExtraInt3IsSet(false); + this.extraInt3 = 0; + setExtraLong1IsSet(false); + this.extraLong1 = 0; + setExtraLong2IsSet(false); + this.extraLong2 = 0; + setExtraLong3IsSet(false); + this.extraLong3 = 0; + } + + public int getDataType() { + return this.dataType; + } + + public RequestDataThriftDTO setDataType(int dataType) { + this.dataType = dataType; + setDataTypeIsSet(true); + return this; + } + + public void unsetDataType() { + __isset_bit_vector.clear(__DATATYPE_ISSET_ID); + } + + /** Returns true if field dataType is set (has been assigned a value) and false otherwise */ + public boolean isSetDataType() { + return __isset_bit_vector.get(__DATATYPE_ISSET_ID); + } + + public void setDataTypeIsSet(boolean value) { + __isset_bit_vector.set(__DATATYPE_ISSET_ID, value); + } + + public long getDataTime() { + return this.dataTime; + } + + public RequestDataThriftDTO setDataTime(long dataTime) { + this.dataTime = dataTime; + setDataTimeIsSet(true); + return this; + } + + public void unsetDataTime() { + __isset_bit_vector.clear(__DATATIME_ISSET_ID); + } + + /** Returns true if field dataTime is set (has been assigned a value) and false otherwise */ + public boolean isSetDataTime() { + return __isset_bit_vector.get(__DATATIME_ISSET_ID); + } + + public void setDataTimeIsSet(boolean value) { + __isset_bit_vector.set(__DATATIME_ISSET_ID, value); + } + + public int getDataHashCode() { + return this.dataHashCode; + } + + public RequestDataThriftDTO setDataHashCode(int dataHashCode) { + this.dataHashCode = dataHashCode; + setDataHashCodeIsSet(true); + return this; + } + + public void unsetDataHashCode() { + __isset_bit_vector.clear(__DATAHASHCODE_ISSET_ID); + } + + /** Returns true if field dataHashCode is set (has been assigned a value) and false otherwise */ + public boolean isSetDataHashCode() { + return __isset_bit_vector.get(__DATAHASHCODE_ISSET_ID); + } + + public void setDataHashCodeIsSet(boolean value) { + __isset_bit_vector.set(__DATAHASHCODE_ISSET_ID, value); + } + + public String getDataString() { + return this.dataString; + } + + public RequestDataThriftDTO setDataString(String dataString) { + this.dataString = dataString; + return this; + } + + public void unsetDataString() { + this.dataString = null; + } + + /** Returns true if field dataString is set (has been assigned a value) and false otherwise */ + public boolean isSetDataString() { + return this.dataString != null; + } + + public void setDataStringIsSet(boolean value) { + if (!value) { + this.dataString = null; + } + } + + public String getExtraData1() { + return this.extraData1; + } + + public RequestDataThriftDTO setExtraData1(String extraData1) { + this.extraData1 = extraData1; + return this; + } + + public void unsetExtraData1() { + this.extraData1 = null; + } + + /** Returns true if field extraData1 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraData1() { + return this.extraData1 != null; + } + + public void setExtraData1IsSet(boolean value) { + if (!value) { + this.extraData1 = null; + } + } + + public String getExtraData2() { + return this.extraData2; + } + + public RequestDataThriftDTO setExtraData2(String extraData2) { + this.extraData2 = extraData2; + return this; + } + + public void unsetExtraData2() { + this.extraData2 = null; + } + + /** Returns true if field extraData2 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraData2() { + return this.extraData2 != null; + } + + public void setExtraData2IsSet(boolean value) { + if (!value) { + this.extraData2 = null; + } + } + + public String getExtraData3() { + return this.extraData3; + } + + public RequestDataThriftDTO setExtraData3(String extraData3) { + this.extraData3 = extraData3; + return this; + } + + public void unsetExtraData3() { + this.extraData3 = null; + } + + /** Returns true if field extraData3 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraData3() { + return this.extraData3 != null; + } + + public void setExtraData3IsSet(boolean value) { + if (!value) { + this.extraData3 = null; + } + } + + public int getExtraInt1() { + return this.extraInt1; + } + + public RequestDataThriftDTO setExtraInt1(int extraInt1) { + this.extraInt1 = extraInt1; + setExtraInt1IsSet(true); + return this; + } + + public void unsetExtraInt1() { + __isset_bit_vector.clear(__EXTRAINT1_ISSET_ID); + } + + /** Returns true if field extraInt1 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraInt1() { + return __isset_bit_vector.get(__EXTRAINT1_ISSET_ID); + } + + public void setExtraInt1IsSet(boolean value) { + __isset_bit_vector.set(__EXTRAINT1_ISSET_ID, value); + } + + public int getExtraInt2() { + return this.extraInt2; + } + + public RequestDataThriftDTO setExtraInt2(int extraInt2) { + this.extraInt2 = extraInt2; + setExtraInt2IsSet(true); + return this; + } + + public void unsetExtraInt2() { + __isset_bit_vector.clear(__EXTRAINT2_ISSET_ID); + } + + /** Returns true if field extraInt2 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraInt2() { + return __isset_bit_vector.get(__EXTRAINT2_ISSET_ID); + } + + public void setExtraInt2IsSet(boolean value) { + __isset_bit_vector.set(__EXTRAINT2_ISSET_ID, value); + } + + public int getExtraInt3() { + return this.extraInt3; + } + + public RequestDataThriftDTO setExtraInt3(int extraInt3) { + this.extraInt3 = extraInt3; + setExtraInt3IsSet(true); + return this; + } + + public void unsetExtraInt3() { + __isset_bit_vector.clear(__EXTRAINT3_ISSET_ID); + } + + /** Returns true if field extraInt3 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraInt3() { + return __isset_bit_vector.get(__EXTRAINT3_ISSET_ID); + } + + public void setExtraInt3IsSet(boolean value) { + __isset_bit_vector.set(__EXTRAINT3_ISSET_ID, value); + } + + public long getExtraLong1() { + return this.extraLong1; + } + + public RequestDataThriftDTO setExtraLong1(long extraLong1) { + this.extraLong1 = extraLong1; + setExtraLong1IsSet(true); + return this; + } + + public void unsetExtraLong1() { + __isset_bit_vector.clear(__EXTRALONG1_ISSET_ID); + } + + /** Returns true if field extraLong1 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraLong1() { + return __isset_bit_vector.get(__EXTRALONG1_ISSET_ID); + } + + public void setExtraLong1IsSet(boolean value) { + __isset_bit_vector.set(__EXTRALONG1_ISSET_ID, value); + } + + public long getExtraLong2() { + return this.extraLong2; + } + + public RequestDataThriftDTO setExtraLong2(long extraLong2) { + this.extraLong2 = extraLong2; + setExtraLong2IsSet(true); + return this; + } + + public void unsetExtraLong2() { + __isset_bit_vector.clear(__EXTRALONG2_ISSET_ID); + } + + /** Returns true if field extraLong2 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraLong2() { + return __isset_bit_vector.get(__EXTRALONG2_ISSET_ID); + } + + public void setExtraLong2IsSet(boolean value) { + __isset_bit_vector.set(__EXTRALONG2_ISSET_ID, value); + } + + public long getExtraLong3() { + return this.extraLong3; + } + + public RequestDataThriftDTO setExtraLong3(long extraLong3) { + this.extraLong3 = extraLong3; + setExtraLong3IsSet(true); + return this; + } + + public void unsetExtraLong3() { + __isset_bit_vector.clear(__EXTRALONG3_ISSET_ID); + } + + /** Returns true if field extraLong3 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraLong3() { + return __isset_bit_vector.get(__EXTRALONG3_ISSET_ID); + } + + public void setExtraLong3IsSet(boolean value) { + __isset_bit_vector.set(__EXTRALONG3_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case DATA_TYPE: + if (value == null) { + unsetDataType(); + } else { + setDataType((Integer)value); + } + break; + + case DATA_TIME: + if (value == null) { + unsetDataTime(); + } else { + setDataTime((Long)value); + } + break; + + case DATA_HASH_CODE: + if (value == null) { + unsetDataHashCode(); + } else { + setDataHashCode((Integer)value); + } + break; + + case DATA_STRING: + if (value == null) { + unsetDataString(); + } else { + setDataString((String)value); + } + break; + + case EXTRA_DATA1: + if (value == null) { + unsetExtraData1(); + } else { + setExtraData1((String)value); + } + break; + + case EXTRA_DATA2: + if (value == null) { + unsetExtraData2(); + } else { + setExtraData2((String)value); + } + break; + + case EXTRA_DATA3: + if (value == null) { + unsetExtraData3(); + } else { + setExtraData3((String)value); + } + break; + + case EXTRA_INT1: + if (value == null) { + unsetExtraInt1(); + } else { + setExtraInt1((Integer)value); + } + break; + + case EXTRA_INT2: + if (value == null) { + unsetExtraInt2(); + } else { + setExtraInt2((Integer)value); + } + break; + + case EXTRA_INT3: + if (value == null) { + unsetExtraInt3(); + } else { + setExtraInt3((Integer)value); + } + break; + + case EXTRA_LONG1: + if (value == null) { + unsetExtraLong1(); + } else { + setExtraLong1((Long)value); + } + break; + + case EXTRA_LONG2: + if (value == null) { + unsetExtraLong2(); + } else { + setExtraLong2((Long)value); + } + break; + + case EXTRA_LONG3: + if (value == null) { + unsetExtraLong3(); + } else { + setExtraLong3((Long)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case DATA_TYPE: + return Integer.valueOf(getDataType()); + + case DATA_TIME: + return Long.valueOf(getDataTime()); + + case DATA_HASH_CODE: + return Integer.valueOf(getDataHashCode()); + + case DATA_STRING: + return getDataString(); + + case EXTRA_DATA1: + return getExtraData1(); + + case EXTRA_DATA2: + return getExtraData2(); + + case EXTRA_DATA3: + return getExtraData3(); + + case EXTRA_INT1: + return Integer.valueOf(getExtraInt1()); + + case EXTRA_INT2: + return Integer.valueOf(getExtraInt2()); + + case EXTRA_INT3: + return Integer.valueOf(getExtraInt3()); + + case EXTRA_LONG1: + return Long.valueOf(getExtraLong1()); + + case EXTRA_LONG2: + return Long.valueOf(getExtraLong2()); + + case EXTRA_LONG3: + return Long.valueOf(getExtraLong3()); + + } + 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 DATA_TYPE: + return isSetDataType(); + case DATA_TIME: + return isSetDataTime(); + case DATA_HASH_CODE: + return isSetDataHashCode(); + case DATA_STRING: + return isSetDataString(); + case EXTRA_DATA1: + return isSetExtraData1(); + case EXTRA_DATA2: + return isSetExtraData2(); + case EXTRA_DATA3: + return isSetExtraData3(); + case EXTRA_INT1: + return isSetExtraInt1(); + case EXTRA_INT2: + return isSetExtraInt2(); + case EXTRA_INT3: + return isSetExtraInt3(); + case EXTRA_LONG1: + return isSetExtraLong1(); + case EXTRA_LONG2: + return isSetExtraLong2(); + case EXTRA_LONG3: + return isSetExtraLong3(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof RequestDataThriftDTO) + return this.equals((RequestDataThriftDTO)that); + return false; + } + + public boolean equals(RequestDataThriftDTO that) { + if (that == null) + return false; + + boolean this_present_dataType = true; + boolean that_present_dataType = true; + if (this_present_dataType || that_present_dataType) { + if (!(this_present_dataType && that_present_dataType)) + return false; + if (this.dataType != that.dataType) + return false; + } + + boolean this_present_dataTime = true; + boolean that_present_dataTime = true; + if (this_present_dataTime || that_present_dataTime) { + if (!(this_present_dataTime && that_present_dataTime)) + return false; + if (this.dataTime != that.dataTime) + return false; + } + + boolean this_present_dataHashCode = true && this.isSetDataHashCode(); + boolean that_present_dataHashCode = true && that.isSetDataHashCode(); + if (this_present_dataHashCode || that_present_dataHashCode) { + if (!(this_present_dataHashCode && that_present_dataHashCode)) + return false; + if (this.dataHashCode != that.dataHashCode) + return false; + } + + boolean this_present_dataString = true && this.isSetDataString(); + boolean that_present_dataString = true && that.isSetDataString(); + if (this_present_dataString || that_present_dataString) { + if (!(this_present_dataString && that_present_dataString)) + return false; + if (!this.dataString.equals(that.dataString)) + return false; + } + + boolean this_present_extraData1 = true && this.isSetExtraData1(); + boolean that_present_extraData1 = true && that.isSetExtraData1(); + if (this_present_extraData1 || that_present_extraData1) { + if (!(this_present_extraData1 && that_present_extraData1)) + return false; + if (!this.extraData1.equals(that.extraData1)) + return false; + } + + boolean this_present_extraData2 = true && this.isSetExtraData2(); + boolean that_present_extraData2 = true && that.isSetExtraData2(); + if (this_present_extraData2 || that_present_extraData2) { + if (!(this_present_extraData2 && that_present_extraData2)) + return false; + if (!this.extraData2.equals(that.extraData2)) + return false; + } + + boolean this_present_extraData3 = true && this.isSetExtraData3(); + boolean that_present_extraData3 = true && that.isSetExtraData3(); + if (this_present_extraData3 || that_present_extraData3) { + if (!(this_present_extraData3 && that_present_extraData3)) + return false; + if (!this.extraData3.equals(that.extraData3)) + return false; + } + + boolean this_present_extraInt1 = true && this.isSetExtraInt1(); + boolean that_present_extraInt1 = true && that.isSetExtraInt1(); + if (this_present_extraInt1 || that_present_extraInt1) { + if (!(this_present_extraInt1 && that_present_extraInt1)) + return false; + if (this.extraInt1 != that.extraInt1) + return false; + } + + boolean this_present_extraInt2 = true && this.isSetExtraInt2(); + boolean that_present_extraInt2 = true && that.isSetExtraInt2(); + if (this_present_extraInt2 || that_present_extraInt2) { + if (!(this_present_extraInt2 && that_present_extraInt2)) + return false; + if (this.extraInt2 != that.extraInt2) + return false; + } + + boolean this_present_extraInt3 = true && this.isSetExtraInt3(); + boolean that_present_extraInt3 = true && that.isSetExtraInt3(); + if (this_present_extraInt3 || that_present_extraInt3) { + if (!(this_present_extraInt3 && that_present_extraInt3)) + return false; + if (this.extraInt3 != that.extraInt3) + return false; + } + + boolean this_present_extraLong1 = true && this.isSetExtraLong1(); + boolean that_present_extraLong1 = true && that.isSetExtraLong1(); + if (this_present_extraLong1 || that_present_extraLong1) { + if (!(this_present_extraLong1 && that_present_extraLong1)) + return false; + if (this.extraLong1 != that.extraLong1) + return false; + } + + boolean this_present_extraLong2 = true && this.isSetExtraLong2(); + boolean that_present_extraLong2 = true && that.isSetExtraLong2(); + if (this_present_extraLong2 || that_present_extraLong2) { + if (!(this_present_extraLong2 && that_present_extraLong2)) + return false; + if (this.extraLong2 != that.extraLong2) + return false; + } + + boolean this_present_extraLong3 = true && this.isSetExtraLong3(); + boolean that_present_extraLong3 = true && that.isSetExtraLong3(); + if (this_present_extraLong3 || that_present_extraLong3) { + if (!(this_present_extraLong3 && that_present_extraLong3)) + return false; + if (this.extraLong3 != that.extraLong3) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(RequestDataThriftDTO other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + RequestDataThriftDTO typedOther = (RequestDataThriftDTO)other; + + lastComparison = Boolean.valueOf(isSetDataType()).compareTo(typedOther.isSetDataType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDataType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dataType, typedOther.dataType); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDataTime()).compareTo(typedOther.isSetDataTime()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDataTime()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dataTime, typedOther.dataTime); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDataHashCode()).compareTo(typedOther.isSetDataHashCode()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDataHashCode()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dataHashCode, typedOther.dataHashCode); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDataString()).compareTo(typedOther.isSetDataString()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDataString()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dataString, typedOther.dataString); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraData1()).compareTo(typedOther.isSetExtraData1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraData1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraData1, typedOther.extraData1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraData2()).compareTo(typedOther.isSetExtraData2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraData2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraData2, typedOther.extraData2); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraData3()).compareTo(typedOther.isSetExtraData3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraData3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraData3, typedOther.extraData3); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraInt1()).compareTo(typedOther.isSetExtraInt1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraInt1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraInt1, typedOther.extraInt1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraInt2()).compareTo(typedOther.isSetExtraInt2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraInt2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraInt2, typedOther.extraInt2); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraInt3()).compareTo(typedOther.isSetExtraInt3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraInt3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraInt3, typedOther.extraInt3); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraLong1()).compareTo(typedOther.isSetExtraLong1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraLong1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraLong1, typedOther.extraLong1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraLong2()).compareTo(typedOther.isSetExtraLong2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraLong2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraLong2, typedOther.extraLong2); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraLong3()).compareTo(typedOther.isSetExtraLong3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraLong3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraLong3, typedOther.extraLong3); + 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("RequestDataThriftDTO("); + boolean first = true; + + sb.append("dataType:"); + sb.append(this.dataType); + first = false; + if (!first) sb.append(", "); + sb.append("dataTime:"); + sb.append(this.dataTime); + first = false; + if (isSetDataHashCode()) { + if (!first) sb.append(", "); + sb.append("dataHashCode:"); + sb.append(this.dataHashCode); + first = false; + } + if (isSetDataString()) { + if (!first) sb.append(", "); + sb.append("dataString:"); + if (this.dataString == null) { + sb.append("null"); + } else { + sb.append(this.dataString); + } + first = false; + } + if (isSetExtraData1()) { + if (!first) sb.append(", "); + sb.append("extraData1:"); + if (this.extraData1 == null) { + sb.append("null"); + } else { + sb.append(this.extraData1); + } + first = false; + } + if (isSetExtraData2()) { + if (!first) sb.append(", "); + sb.append("extraData2:"); + if (this.extraData2 == null) { + sb.append("null"); + } else { + sb.append(this.extraData2); + } + first = false; + } + if (isSetExtraData3()) { + if (!first) sb.append(", "); + sb.append("extraData3:"); + if (this.extraData3 == null) { + sb.append("null"); + } else { + sb.append(this.extraData3); + } + first = false; + } + if (isSetExtraInt1()) { + if (!first) sb.append(", "); + sb.append("extraInt1:"); + sb.append(this.extraInt1); + first = false; + } + if (isSetExtraInt2()) { + if (!first) sb.append(", "); + sb.append("extraInt2:"); + sb.append(this.extraInt2); + first = false; + } + if (isSetExtraInt3()) { + if (!first) sb.append(", "); + sb.append("extraInt3:"); + sb.append(this.extraInt3); + first = false; + } + if (isSetExtraLong1()) { + if (!first) sb.append(", "); + sb.append("extraLong1:"); + sb.append(this.extraLong1); + first = false; + } + if (isSetExtraLong2()) { + if (!first) sb.append(", "); + sb.append("extraLong2:"); + sb.append(this.extraLong2); + first = false; + } + if (isSetExtraLong3()) { + if (!first) sb.append(", "); + sb.append("extraLong3:"); + sb.append(this.extraLong3); + 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 RequestDataThriftDTOStandardSchemeFactory implements SchemeFactory { + public RequestDataThriftDTOStandardScheme getScheme() { + return new RequestDataThriftDTOStandardScheme(); + } + } + + private static class RequestDataThriftDTOStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, RequestDataThriftDTO 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: // DATA_TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.dataType = iprot.readI32(); + struct.setDataTypeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // DATA_TIME + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.dataTime = iprot.readI64(); + struct.setDataTimeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // DATA_HASH_CODE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.dataHashCode = iprot.readI32(); + struct.setDataHashCodeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // DATA_STRING + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.dataString = iprot.readString(); + struct.setDataStringIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // EXTRA_DATA1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.extraData1 = iprot.readString(); + struct.setExtraData1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 6: // EXTRA_DATA2 + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.extraData2 = iprot.readString(); + struct.setExtraData2IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 7: // EXTRA_DATA3 + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.extraData3 = iprot.readString(); + struct.setExtraData3IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 8: // EXTRA_INT1 + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.extraInt1 = iprot.readI32(); + struct.setExtraInt1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 9: // EXTRA_INT2 + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.extraInt2 = iprot.readI32(); + struct.setExtraInt2IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 10: // EXTRA_INT3 + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.extraInt3 = iprot.readI32(); + struct.setExtraInt3IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 11: // EXTRA_LONG1 + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.extraLong1 = iprot.readI64(); + struct.setExtraLong1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 12: // EXTRA_LONG2 + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.extraLong2 = iprot.readI64(); + struct.setExtraLong2IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 13: // EXTRA_LONG3 + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.extraLong3 = iprot.readI64(); + struct.setExtraLong3IsSet(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, RequestDataThriftDTO struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(DATA_TYPE_FIELD_DESC); + oprot.writeI32(struct.dataType); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(DATA_TIME_FIELD_DESC); + oprot.writeI64(struct.dataTime); + oprot.writeFieldEnd(); + if (struct.isSetDataHashCode()) { + oprot.writeFieldBegin(DATA_HASH_CODE_FIELD_DESC); + oprot.writeI32(struct.dataHashCode); + oprot.writeFieldEnd(); + } + if (struct.dataString != null) { + if (struct.isSetDataString()) { + oprot.writeFieldBegin(DATA_STRING_FIELD_DESC); + oprot.writeString(struct.dataString); + oprot.writeFieldEnd(); + } + } + if (struct.extraData1 != null) { + if (struct.isSetExtraData1()) { + oprot.writeFieldBegin(EXTRA_DATA1_FIELD_DESC); + oprot.writeString(struct.extraData1); + oprot.writeFieldEnd(); + } + } + if (struct.extraData2 != null) { + if (struct.isSetExtraData2()) { + oprot.writeFieldBegin(EXTRA_DATA2_FIELD_DESC); + oprot.writeString(struct.extraData2); + oprot.writeFieldEnd(); + } + } + if (struct.extraData3 != null) { + if (struct.isSetExtraData3()) { + oprot.writeFieldBegin(EXTRA_DATA3_FIELD_DESC); + oprot.writeString(struct.extraData3); + oprot.writeFieldEnd(); + } + } + if (struct.isSetExtraInt1()) { + oprot.writeFieldBegin(EXTRA_INT1_FIELD_DESC); + oprot.writeI32(struct.extraInt1); + oprot.writeFieldEnd(); + } + if (struct.isSetExtraInt2()) { + oprot.writeFieldBegin(EXTRA_INT2_FIELD_DESC); + oprot.writeI32(struct.extraInt2); + oprot.writeFieldEnd(); + } + if (struct.isSetExtraInt3()) { + oprot.writeFieldBegin(EXTRA_INT3_FIELD_DESC); + oprot.writeI32(struct.extraInt3); + oprot.writeFieldEnd(); + } + if (struct.isSetExtraLong1()) { + oprot.writeFieldBegin(EXTRA_LONG1_FIELD_DESC); + oprot.writeI64(struct.extraLong1); + oprot.writeFieldEnd(); + } + if (struct.isSetExtraLong2()) { + oprot.writeFieldBegin(EXTRA_LONG2_FIELD_DESC); + oprot.writeI64(struct.extraLong2); + oprot.writeFieldEnd(); + } + if (struct.isSetExtraLong3()) { + oprot.writeFieldBegin(EXTRA_LONG3_FIELD_DESC); + oprot.writeI64(struct.extraLong3); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class RequestDataThriftDTOTupleSchemeFactory implements SchemeFactory { + public RequestDataThriftDTOTupleScheme getScheme() { + return new RequestDataThriftDTOTupleScheme(); + } + } + + private static class RequestDataThriftDTOTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, RequestDataThriftDTO struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetDataType()) { + optionals.set(0); + } + if (struct.isSetDataTime()) { + optionals.set(1); + } + if (struct.isSetDataHashCode()) { + optionals.set(2); + } + if (struct.isSetDataString()) { + optionals.set(3); + } + if (struct.isSetExtraData1()) { + optionals.set(4); + } + if (struct.isSetExtraData2()) { + optionals.set(5); + } + if (struct.isSetExtraData3()) { + optionals.set(6); + } + if (struct.isSetExtraInt1()) { + optionals.set(7); + } + if (struct.isSetExtraInt2()) { + optionals.set(8); + } + if (struct.isSetExtraInt3()) { + optionals.set(9); + } + if (struct.isSetExtraLong1()) { + optionals.set(10); + } + if (struct.isSetExtraLong2()) { + optionals.set(11); + } + if (struct.isSetExtraLong3()) { + optionals.set(12); + } + oprot.writeBitSet(optionals, 13); + if (struct.isSetDataType()) { + oprot.writeI32(struct.dataType); + } + if (struct.isSetDataTime()) { + oprot.writeI64(struct.dataTime); + } + if (struct.isSetDataHashCode()) { + oprot.writeI32(struct.dataHashCode); + } + if (struct.isSetDataString()) { + oprot.writeString(struct.dataString); + } + if (struct.isSetExtraData1()) { + oprot.writeString(struct.extraData1); + } + if (struct.isSetExtraData2()) { + oprot.writeString(struct.extraData2); + } + if (struct.isSetExtraData3()) { + oprot.writeString(struct.extraData3); + } + if (struct.isSetExtraInt1()) { + oprot.writeI32(struct.extraInt1); + } + if (struct.isSetExtraInt2()) { + oprot.writeI32(struct.extraInt2); + } + if (struct.isSetExtraInt3()) { + oprot.writeI32(struct.extraInt3); + } + if (struct.isSetExtraLong1()) { + oprot.writeI64(struct.extraLong1); + } + if (struct.isSetExtraLong2()) { + oprot.writeI64(struct.extraLong2); + } + if (struct.isSetExtraLong3()) { + oprot.writeI64(struct.extraLong3); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, RequestDataThriftDTO struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(13); + if (incoming.get(0)) { + struct.dataType = iprot.readI32(); + struct.setDataTypeIsSet(true); + } + if (incoming.get(1)) { + struct.dataTime = iprot.readI64(); + struct.setDataTimeIsSet(true); + } + if (incoming.get(2)) { + struct.dataHashCode = iprot.readI32(); + struct.setDataHashCodeIsSet(true); + } + if (incoming.get(3)) { + struct.dataString = iprot.readString(); + struct.setDataStringIsSet(true); + } + if (incoming.get(4)) { + struct.extraData1 = iprot.readString(); + struct.setExtraData1IsSet(true); + } + if (incoming.get(5)) { + struct.extraData2 = iprot.readString(); + struct.setExtraData2IsSet(true); + } + if (incoming.get(6)) { + struct.extraData3 = iprot.readString(); + struct.setExtraData3IsSet(true); + } + if (incoming.get(7)) { + struct.extraInt1 = iprot.readI32(); + struct.setExtraInt1IsSet(true); + } + if (incoming.get(8)) { + struct.extraInt2 = iprot.readI32(); + struct.setExtraInt2IsSet(true); + } + if (incoming.get(9)) { + struct.extraInt3 = iprot.readI32(); + struct.setExtraInt3IsSet(true); + } + if (incoming.get(10)) { + struct.extraLong1 = iprot.readI64(); + struct.setExtraLong1IsSet(true); + } + if (incoming.get(11)) { + struct.extraLong2 = iprot.readI64(); + struct.setExtraLong2IsSet(true); + } + if (incoming.get(12)) { + struct.extraLong3 = iprot.readI64(); + struct.setExtraLong3IsSet(true); + } + } + } + +} + diff --git a/src/com/profiler/dto/RequestThriftDTO.java b/src/com/profiler/dto/RequestThriftDTO.java new file mode 100644 index 000000000..1b8f6008e --- /dev/null +++ b/src/com/profiler/dto/RequestThriftDTO.java @@ -0,0 +1,2034 @@ +/** + * 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 RequestThriftDTO implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RequestThriftDTO"); + + 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 DATA_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("dataType", org.apache.thrift.protocol.TType.I32, (short)3); + private static final org.apache.thrift.protocol.TField DATA_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("dataTime", org.apache.thrift.protocol.TType.I64, (short)4); + private static final org.apache.thrift.protocol.TField THREAD_CPUTIME_FIELD_DESC = new org.apache.thrift.protocol.TField("threadCPUTime", org.apache.thrift.protocol.TType.I64, (short)5); + private static final org.apache.thrift.protocol.TField THREAD_USER_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("threadUserTime", org.apache.thrift.protocol.TType.I64, (short)6); + private static final org.apache.thrift.protocol.TField REQUEST_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("requestID", org.apache.thrift.protocol.TType.STRING, (short)7); + private static final org.apache.thrift.protocol.TField REQUEST_URL_FIELD_DESC = new org.apache.thrift.protocol.TField("requestURL", org.apache.thrift.protocol.TType.STRING, (short)8); + private static final org.apache.thrift.protocol.TField CLIENT_IP_FIELD_DESC = new org.apache.thrift.protocol.TField("clientIP", org.apache.thrift.protocol.TType.STRING, (short)9); + private static final org.apache.thrift.protocol.TField EXTRA_DATA1_FIELD_DESC = new org.apache.thrift.protocol.TField("extraData1", org.apache.thrift.protocol.TType.STRING, (short)10); + private static final org.apache.thrift.protocol.TField EXTRA_DATA2_FIELD_DESC = new org.apache.thrift.protocol.TField("extraData2", org.apache.thrift.protocol.TType.STRING, (short)11); + private static final org.apache.thrift.protocol.TField EXTRA_DATA3_FIELD_DESC = new org.apache.thrift.protocol.TField("extraData3", org.apache.thrift.protocol.TType.STRING, (short)12); + private static final org.apache.thrift.protocol.TField EXTRA_INT1_FIELD_DESC = new org.apache.thrift.protocol.TField("extraInt1", org.apache.thrift.protocol.TType.I32, (short)13); + private static final org.apache.thrift.protocol.TField EXTRA_INT2_FIELD_DESC = new org.apache.thrift.protocol.TField("extraInt2", org.apache.thrift.protocol.TType.I32, (short)14); + private static final org.apache.thrift.protocol.TField EXTRA_INT3_FIELD_DESC = new org.apache.thrift.protocol.TField("extraInt3", org.apache.thrift.protocol.TType.I32, (short)15); + private static final org.apache.thrift.protocol.TField EXTRA_LONG1_FIELD_DESC = new org.apache.thrift.protocol.TField("extraLong1", org.apache.thrift.protocol.TType.I64, (short)16); + private static final org.apache.thrift.protocol.TField EXTRA_LONG2_FIELD_DESC = new org.apache.thrift.protocol.TField("extraLong2", org.apache.thrift.protocol.TType.I64, (short)17); + private static final org.apache.thrift.protocol.TField EXTRA_LONG3_FIELD_DESC = new org.apache.thrift.protocol.TField("extraLong3", org.apache.thrift.protocol.TType.I64, (short)18); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new RequestThriftDTOStandardSchemeFactory()); + schemes.put(TupleScheme.class, new RequestThriftDTOTupleSchemeFactory()); + } + + public int hostHashCode; // required + public int requestHashCode; // required + public int dataType; // required + public long dataTime; // required + public long threadCPUTime; // required + public long threadUserTime; // required + public String requestID; // optional + public String requestURL; // optional + public String clientIP; // optional + public String extraData1; // optional + public String extraData2; // optional + public String extraData3; // optional + public int extraInt1; // optional + public int extraInt2; // optional + public int extraInt3; // optional + public long extraLong1; // optional + public long extraLong2; // optional + public long extraLong3; // optional + + /** 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"), + DATA_TYPE((short)3, "dataType"), + DATA_TIME((short)4, "dataTime"), + THREAD_CPUTIME((short)5, "threadCPUTime"), + THREAD_USER_TIME((short)6, "threadUserTime"), + REQUEST_ID((short)7, "requestID"), + REQUEST_URL((short)8, "requestURL"), + CLIENT_IP((short)9, "clientIP"), + EXTRA_DATA1((short)10, "extraData1"), + EXTRA_DATA2((short)11, "extraData2"), + EXTRA_DATA3((short)12, "extraData3"), + EXTRA_INT1((short)13, "extraInt1"), + EXTRA_INT2((short)14, "extraInt2"), + EXTRA_INT3((short)15, "extraInt3"), + EXTRA_LONG1((short)16, "extraLong1"), + EXTRA_LONG2((short)17, "extraLong2"), + EXTRA_LONG3((short)18, "extraLong3"); + + private static final Map byName = new HashMap(); + + 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: // DATA_TYPE + return DATA_TYPE; + case 4: // DATA_TIME + return DATA_TIME; + case 5: // THREAD_CPUTIME + return THREAD_CPUTIME; + case 6: // THREAD_USER_TIME + return THREAD_USER_TIME; + case 7: // REQUEST_ID + return REQUEST_ID; + case 8: // REQUEST_URL + return REQUEST_URL; + case 9: // CLIENT_IP + return CLIENT_IP; + case 10: // EXTRA_DATA1 + return EXTRA_DATA1; + case 11: // EXTRA_DATA2 + return EXTRA_DATA2; + case 12: // EXTRA_DATA3 + return EXTRA_DATA3; + case 13: // EXTRA_INT1 + return EXTRA_INT1; + case 14: // EXTRA_INT2 + return EXTRA_INT2; + case 15: // EXTRA_INT3 + return EXTRA_INT3; + case 16: // EXTRA_LONG1 + return EXTRA_LONG1; + case 17: // EXTRA_LONG2 + return EXTRA_LONG2; + case 18: // EXTRA_LONG3 + return EXTRA_LONG3; + 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 static final int __DATATYPE_ISSET_ID = 2; + private static final int __DATATIME_ISSET_ID = 3; + private static final int __THREADCPUTIME_ISSET_ID = 4; + private static final int __THREADUSERTIME_ISSET_ID = 5; + private static final int __EXTRAINT1_ISSET_ID = 6; + private static final int __EXTRAINT2_ISSET_ID = 7; + private static final int __EXTRAINT3_ISSET_ID = 8; + private static final int __EXTRALONG1_ISSET_ID = 9; + private static final int __EXTRALONG2_ISSET_ID = 10; + private static final int __EXTRALONG3_ISSET_ID = 11; + private BitSet __isset_bit_vector = new BitSet(12); + private _Fields optionals[] = {_Fields.REQUEST_ID,_Fields.REQUEST_URL,_Fields.CLIENT_IP,_Fields.EXTRA_DATA1,_Fields.EXTRA_DATA2,_Fields.EXTRA_DATA3,_Fields.EXTRA_INT1,_Fields.EXTRA_INT2,_Fields.EXTRA_INT3,_Fields.EXTRA_LONG1,_Fields.EXTRA_LONG2,_Fields.EXTRA_LONG3}; + 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.DATA_TYPE, new org.apache.thrift.meta_data.FieldMetaData("dataType", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.DATA_TIME, new org.apache.thrift.meta_data.FieldMetaData("dataTime", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.THREAD_CPUTIME, new org.apache.thrift.meta_data.FieldMetaData("threadCPUTime", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.THREAD_USER_TIME, new org.apache.thrift.meta_data.FieldMetaData("threadUserTime", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.REQUEST_ID, new org.apache.thrift.meta_data.FieldMetaData("requestID", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.REQUEST_URL, new org.apache.thrift.meta_data.FieldMetaData("requestURL", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.CLIENT_IP, new org.apache.thrift.meta_data.FieldMetaData("clientIP", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.EXTRA_DATA1, new org.apache.thrift.meta_data.FieldMetaData("extraData1", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.EXTRA_DATA2, new org.apache.thrift.meta_data.FieldMetaData("extraData2", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.EXTRA_DATA3, new org.apache.thrift.meta_data.FieldMetaData("extraData3", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.EXTRA_INT1, new org.apache.thrift.meta_data.FieldMetaData("extraInt1", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.EXTRA_INT2, new org.apache.thrift.meta_data.FieldMetaData("extraInt2", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.EXTRA_INT3, new org.apache.thrift.meta_data.FieldMetaData("extraInt3", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.EXTRA_LONG1, new org.apache.thrift.meta_data.FieldMetaData("extraLong1", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.EXTRA_LONG2, new org.apache.thrift.meta_data.FieldMetaData("extraLong2", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.EXTRA_LONG3, new org.apache.thrift.meta_data.FieldMetaData("extraLong3", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(RequestThriftDTO.class, metaDataMap); + } + + public RequestThriftDTO() { + } + + public RequestThriftDTO( + int hostHashCode, + int requestHashCode, + int dataType, + long dataTime, + long threadCPUTime, + long threadUserTime) + { + this(); + this.hostHashCode = hostHashCode; + setHostHashCodeIsSet(true); + this.requestHashCode = requestHashCode; + setRequestHashCodeIsSet(true); + this.dataType = dataType; + setDataTypeIsSet(true); + this.dataTime = dataTime; + setDataTimeIsSet(true); + this.threadCPUTime = threadCPUTime; + setThreadCPUTimeIsSet(true); + this.threadUserTime = threadUserTime; + setThreadUserTimeIsSet(true); + } + + /** + * Performs a deep copy on other. + */ + public RequestThriftDTO(RequestThriftDTO other) { + __isset_bit_vector.clear(); + __isset_bit_vector.or(other.__isset_bit_vector); + this.hostHashCode = other.hostHashCode; + this.requestHashCode = other.requestHashCode; + this.dataType = other.dataType; + this.dataTime = other.dataTime; + this.threadCPUTime = other.threadCPUTime; + this.threadUserTime = other.threadUserTime; + if (other.isSetRequestID()) { + this.requestID = other.requestID; + } + if (other.isSetRequestURL()) { + this.requestURL = other.requestURL; + } + if (other.isSetClientIP()) { + this.clientIP = other.clientIP; + } + if (other.isSetExtraData1()) { + this.extraData1 = other.extraData1; + } + if (other.isSetExtraData2()) { + this.extraData2 = other.extraData2; + } + if (other.isSetExtraData3()) { + this.extraData3 = other.extraData3; + } + this.extraInt1 = other.extraInt1; + this.extraInt2 = other.extraInt2; + this.extraInt3 = other.extraInt3; + this.extraLong1 = other.extraLong1; + this.extraLong2 = other.extraLong2; + this.extraLong3 = other.extraLong3; + } + + public RequestThriftDTO deepCopy() { + return new RequestThriftDTO(this); + } + + @Override + public void clear() { + setHostHashCodeIsSet(false); + this.hostHashCode = 0; + setRequestHashCodeIsSet(false); + this.requestHashCode = 0; + setDataTypeIsSet(false); + this.dataType = 0; + setDataTimeIsSet(false); + this.dataTime = 0; + setThreadCPUTimeIsSet(false); + this.threadCPUTime = 0; + setThreadUserTimeIsSet(false); + this.threadUserTime = 0; + this.requestID = null; + this.requestURL = null; + this.clientIP = null; + this.extraData1 = null; + this.extraData2 = null; + this.extraData3 = null; + setExtraInt1IsSet(false); + this.extraInt1 = 0; + setExtraInt2IsSet(false); + this.extraInt2 = 0; + setExtraInt3IsSet(false); + this.extraInt3 = 0; + setExtraLong1IsSet(false); + this.extraLong1 = 0; + setExtraLong2IsSet(false); + this.extraLong2 = 0; + setExtraLong3IsSet(false); + this.extraLong3 = 0; + } + + public int getHostHashCode() { + return this.hostHashCode; + } + + public RequestThriftDTO 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 RequestThriftDTO 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 getDataType() { + return this.dataType; + } + + public RequestThriftDTO setDataType(int dataType) { + this.dataType = dataType; + setDataTypeIsSet(true); + return this; + } + + public void unsetDataType() { + __isset_bit_vector.clear(__DATATYPE_ISSET_ID); + } + + /** Returns true if field dataType is set (has been assigned a value) and false otherwise */ + public boolean isSetDataType() { + return __isset_bit_vector.get(__DATATYPE_ISSET_ID); + } + + public void setDataTypeIsSet(boolean value) { + __isset_bit_vector.set(__DATATYPE_ISSET_ID, value); + } + + public long getDataTime() { + return this.dataTime; + } + + public RequestThriftDTO setDataTime(long dataTime) { + this.dataTime = dataTime; + setDataTimeIsSet(true); + return this; + } + + public void unsetDataTime() { + __isset_bit_vector.clear(__DATATIME_ISSET_ID); + } + + /** Returns true if field dataTime is set (has been assigned a value) and false otherwise */ + public boolean isSetDataTime() { + return __isset_bit_vector.get(__DATATIME_ISSET_ID); + } + + public void setDataTimeIsSet(boolean value) { + __isset_bit_vector.set(__DATATIME_ISSET_ID, value); + } + + public long getThreadCPUTime() { + return this.threadCPUTime; + } + + public RequestThriftDTO setThreadCPUTime(long threadCPUTime) { + this.threadCPUTime = threadCPUTime; + setThreadCPUTimeIsSet(true); + return this; + } + + public void unsetThreadCPUTime() { + __isset_bit_vector.clear(__THREADCPUTIME_ISSET_ID); + } + + /** Returns true if field threadCPUTime is set (has been assigned a value) and false otherwise */ + public boolean isSetThreadCPUTime() { + return __isset_bit_vector.get(__THREADCPUTIME_ISSET_ID); + } + + public void setThreadCPUTimeIsSet(boolean value) { + __isset_bit_vector.set(__THREADCPUTIME_ISSET_ID, value); + } + + public long getThreadUserTime() { + return this.threadUserTime; + } + + public RequestThriftDTO setThreadUserTime(long threadUserTime) { + this.threadUserTime = threadUserTime; + setThreadUserTimeIsSet(true); + return this; + } + + public void unsetThreadUserTime() { + __isset_bit_vector.clear(__THREADUSERTIME_ISSET_ID); + } + + /** Returns true if field threadUserTime is set (has been assigned a value) and false otherwise */ + public boolean isSetThreadUserTime() { + return __isset_bit_vector.get(__THREADUSERTIME_ISSET_ID); + } + + public void setThreadUserTimeIsSet(boolean value) { + __isset_bit_vector.set(__THREADUSERTIME_ISSET_ID, value); + } + + public String getRequestID() { + return this.requestID; + } + + public RequestThriftDTO setRequestID(String requestID) { + this.requestID = requestID; + return this; + } + + public void unsetRequestID() { + this.requestID = null; + } + + /** Returns true if field requestID is set (has been assigned a value) and false otherwise */ + public boolean isSetRequestID() { + return this.requestID != null; + } + + public void setRequestIDIsSet(boolean value) { + if (!value) { + this.requestID = null; + } + } + + public String getRequestURL() { + return this.requestURL; + } + + public RequestThriftDTO setRequestURL(String requestURL) { + this.requestURL = requestURL; + return this; + } + + public void unsetRequestURL() { + this.requestURL = null; + } + + /** Returns true if field requestURL is set (has been assigned a value) and false otherwise */ + public boolean isSetRequestURL() { + return this.requestURL != null; + } + + public void setRequestURLIsSet(boolean value) { + if (!value) { + this.requestURL = null; + } + } + + public String getClientIP() { + return this.clientIP; + } + + public RequestThriftDTO setClientIP(String clientIP) { + this.clientIP = clientIP; + return this; + } + + public void unsetClientIP() { + this.clientIP = null; + } + + /** Returns true if field clientIP is set (has been assigned a value) and false otherwise */ + public boolean isSetClientIP() { + return this.clientIP != null; + } + + public void setClientIPIsSet(boolean value) { + if (!value) { + this.clientIP = null; + } + } + + public String getExtraData1() { + return this.extraData1; + } + + public RequestThriftDTO setExtraData1(String extraData1) { + this.extraData1 = extraData1; + return this; + } + + public void unsetExtraData1() { + this.extraData1 = null; + } + + /** Returns true if field extraData1 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraData1() { + return this.extraData1 != null; + } + + public void setExtraData1IsSet(boolean value) { + if (!value) { + this.extraData1 = null; + } + } + + public String getExtraData2() { + return this.extraData2; + } + + public RequestThriftDTO setExtraData2(String extraData2) { + this.extraData2 = extraData2; + return this; + } + + public void unsetExtraData2() { + this.extraData2 = null; + } + + /** Returns true if field extraData2 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraData2() { + return this.extraData2 != null; + } + + public void setExtraData2IsSet(boolean value) { + if (!value) { + this.extraData2 = null; + } + } + + public String getExtraData3() { + return this.extraData3; + } + + public RequestThriftDTO setExtraData3(String extraData3) { + this.extraData3 = extraData3; + return this; + } + + public void unsetExtraData3() { + this.extraData3 = null; + } + + /** Returns true if field extraData3 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraData3() { + return this.extraData3 != null; + } + + public void setExtraData3IsSet(boolean value) { + if (!value) { + this.extraData3 = null; + } + } + + public int getExtraInt1() { + return this.extraInt1; + } + + public RequestThriftDTO setExtraInt1(int extraInt1) { + this.extraInt1 = extraInt1; + setExtraInt1IsSet(true); + return this; + } + + public void unsetExtraInt1() { + __isset_bit_vector.clear(__EXTRAINT1_ISSET_ID); + } + + /** Returns true if field extraInt1 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraInt1() { + return __isset_bit_vector.get(__EXTRAINT1_ISSET_ID); + } + + public void setExtraInt1IsSet(boolean value) { + __isset_bit_vector.set(__EXTRAINT1_ISSET_ID, value); + } + + public int getExtraInt2() { + return this.extraInt2; + } + + public RequestThriftDTO setExtraInt2(int extraInt2) { + this.extraInt2 = extraInt2; + setExtraInt2IsSet(true); + return this; + } + + public void unsetExtraInt2() { + __isset_bit_vector.clear(__EXTRAINT2_ISSET_ID); + } + + /** Returns true if field extraInt2 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraInt2() { + return __isset_bit_vector.get(__EXTRAINT2_ISSET_ID); + } + + public void setExtraInt2IsSet(boolean value) { + __isset_bit_vector.set(__EXTRAINT2_ISSET_ID, value); + } + + public int getExtraInt3() { + return this.extraInt3; + } + + public RequestThriftDTO setExtraInt3(int extraInt3) { + this.extraInt3 = extraInt3; + setExtraInt3IsSet(true); + return this; + } + + public void unsetExtraInt3() { + __isset_bit_vector.clear(__EXTRAINT3_ISSET_ID); + } + + /** Returns true if field extraInt3 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraInt3() { + return __isset_bit_vector.get(__EXTRAINT3_ISSET_ID); + } + + public void setExtraInt3IsSet(boolean value) { + __isset_bit_vector.set(__EXTRAINT3_ISSET_ID, value); + } + + public long getExtraLong1() { + return this.extraLong1; + } + + public RequestThriftDTO setExtraLong1(long extraLong1) { + this.extraLong1 = extraLong1; + setExtraLong1IsSet(true); + return this; + } + + public void unsetExtraLong1() { + __isset_bit_vector.clear(__EXTRALONG1_ISSET_ID); + } + + /** Returns true if field extraLong1 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraLong1() { + return __isset_bit_vector.get(__EXTRALONG1_ISSET_ID); + } + + public void setExtraLong1IsSet(boolean value) { + __isset_bit_vector.set(__EXTRALONG1_ISSET_ID, value); + } + + public long getExtraLong2() { + return this.extraLong2; + } + + public RequestThriftDTO setExtraLong2(long extraLong2) { + this.extraLong2 = extraLong2; + setExtraLong2IsSet(true); + return this; + } + + public void unsetExtraLong2() { + __isset_bit_vector.clear(__EXTRALONG2_ISSET_ID); + } + + /** Returns true if field extraLong2 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraLong2() { + return __isset_bit_vector.get(__EXTRALONG2_ISSET_ID); + } + + public void setExtraLong2IsSet(boolean value) { + __isset_bit_vector.set(__EXTRALONG2_ISSET_ID, value); + } + + public long getExtraLong3() { + return this.extraLong3; + } + + public RequestThriftDTO setExtraLong3(long extraLong3) { + this.extraLong3 = extraLong3; + setExtraLong3IsSet(true); + return this; + } + + public void unsetExtraLong3() { + __isset_bit_vector.clear(__EXTRALONG3_ISSET_ID); + } + + /** Returns true if field extraLong3 is set (has been assigned a value) and false otherwise */ + public boolean isSetExtraLong3() { + return __isset_bit_vector.get(__EXTRALONG3_ISSET_ID); + } + + public void setExtraLong3IsSet(boolean value) { + __isset_bit_vector.set(__EXTRALONG3_ISSET_ID, value); + } + + 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 DATA_TYPE: + if (value == null) { + unsetDataType(); + } else { + setDataType((Integer)value); + } + break; + + case DATA_TIME: + if (value == null) { + unsetDataTime(); + } else { + setDataTime((Long)value); + } + break; + + case THREAD_CPUTIME: + if (value == null) { + unsetThreadCPUTime(); + } else { + setThreadCPUTime((Long)value); + } + break; + + case THREAD_USER_TIME: + if (value == null) { + unsetThreadUserTime(); + } else { + setThreadUserTime((Long)value); + } + break; + + case REQUEST_ID: + if (value == null) { + unsetRequestID(); + } else { + setRequestID((String)value); + } + break; + + case REQUEST_URL: + if (value == null) { + unsetRequestURL(); + } else { + setRequestURL((String)value); + } + break; + + case CLIENT_IP: + if (value == null) { + unsetClientIP(); + } else { + setClientIP((String)value); + } + break; + + case EXTRA_DATA1: + if (value == null) { + unsetExtraData1(); + } else { + setExtraData1((String)value); + } + break; + + case EXTRA_DATA2: + if (value == null) { + unsetExtraData2(); + } else { + setExtraData2((String)value); + } + break; + + case EXTRA_DATA3: + if (value == null) { + unsetExtraData3(); + } else { + setExtraData3((String)value); + } + break; + + case EXTRA_INT1: + if (value == null) { + unsetExtraInt1(); + } else { + setExtraInt1((Integer)value); + } + break; + + case EXTRA_INT2: + if (value == null) { + unsetExtraInt2(); + } else { + setExtraInt2((Integer)value); + } + break; + + case EXTRA_INT3: + if (value == null) { + unsetExtraInt3(); + } else { + setExtraInt3((Integer)value); + } + break; + + case EXTRA_LONG1: + if (value == null) { + unsetExtraLong1(); + } else { + setExtraLong1((Long)value); + } + break; + + case EXTRA_LONG2: + if (value == null) { + unsetExtraLong2(); + } else { + setExtraLong2((Long)value); + } + break; + + case EXTRA_LONG3: + if (value == null) { + unsetExtraLong3(); + } else { + setExtraLong3((Long)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 DATA_TYPE: + return Integer.valueOf(getDataType()); + + case DATA_TIME: + return Long.valueOf(getDataTime()); + + case THREAD_CPUTIME: + return Long.valueOf(getThreadCPUTime()); + + case THREAD_USER_TIME: + return Long.valueOf(getThreadUserTime()); + + case REQUEST_ID: + return getRequestID(); + + case REQUEST_URL: + return getRequestURL(); + + case CLIENT_IP: + return getClientIP(); + + case EXTRA_DATA1: + return getExtraData1(); + + case EXTRA_DATA2: + return getExtraData2(); + + case EXTRA_DATA3: + return getExtraData3(); + + case EXTRA_INT1: + return Integer.valueOf(getExtraInt1()); + + case EXTRA_INT2: + return Integer.valueOf(getExtraInt2()); + + case EXTRA_INT3: + return Integer.valueOf(getExtraInt3()); + + case EXTRA_LONG1: + return Long.valueOf(getExtraLong1()); + + case EXTRA_LONG2: + return Long.valueOf(getExtraLong2()); + + case EXTRA_LONG3: + return Long.valueOf(getExtraLong3()); + + } + 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 DATA_TYPE: + return isSetDataType(); + case DATA_TIME: + return isSetDataTime(); + case THREAD_CPUTIME: + return isSetThreadCPUTime(); + case THREAD_USER_TIME: + return isSetThreadUserTime(); + case REQUEST_ID: + return isSetRequestID(); + case REQUEST_URL: + return isSetRequestURL(); + case CLIENT_IP: + return isSetClientIP(); + case EXTRA_DATA1: + return isSetExtraData1(); + case EXTRA_DATA2: + return isSetExtraData2(); + case EXTRA_DATA3: + return isSetExtraData3(); + case EXTRA_INT1: + return isSetExtraInt1(); + case EXTRA_INT2: + return isSetExtraInt2(); + case EXTRA_INT3: + return isSetExtraInt3(); + case EXTRA_LONG1: + return isSetExtraLong1(); + case EXTRA_LONG2: + return isSetExtraLong2(); + case EXTRA_LONG3: + return isSetExtraLong3(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof RequestThriftDTO) + return this.equals((RequestThriftDTO)that); + return false; + } + + public boolean equals(RequestThriftDTO 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_dataType = true; + boolean that_present_dataType = true; + if (this_present_dataType || that_present_dataType) { + if (!(this_present_dataType && that_present_dataType)) + return false; + if (this.dataType != that.dataType) + return false; + } + + boolean this_present_dataTime = true; + boolean that_present_dataTime = true; + if (this_present_dataTime || that_present_dataTime) { + if (!(this_present_dataTime && that_present_dataTime)) + return false; + if (this.dataTime != that.dataTime) + return false; + } + + boolean this_present_threadCPUTime = true; + boolean that_present_threadCPUTime = true; + if (this_present_threadCPUTime || that_present_threadCPUTime) { + if (!(this_present_threadCPUTime && that_present_threadCPUTime)) + return false; + if (this.threadCPUTime != that.threadCPUTime) + return false; + } + + boolean this_present_threadUserTime = true; + boolean that_present_threadUserTime = true; + if (this_present_threadUserTime || that_present_threadUserTime) { + if (!(this_present_threadUserTime && that_present_threadUserTime)) + return false; + if (this.threadUserTime != that.threadUserTime) + return false; + } + + boolean this_present_requestID = true && this.isSetRequestID(); + boolean that_present_requestID = true && that.isSetRequestID(); + if (this_present_requestID || that_present_requestID) { + if (!(this_present_requestID && that_present_requestID)) + return false; + if (!this.requestID.equals(that.requestID)) + return false; + } + + boolean this_present_requestURL = true && this.isSetRequestURL(); + boolean that_present_requestURL = true && that.isSetRequestURL(); + if (this_present_requestURL || that_present_requestURL) { + if (!(this_present_requestURL && that_present_requestURL)) + return false; + if (!this.requestURL.equals(that.requestURL)) + return false; + } + + boolean this_present_clientIP = true && this.isSetClientIP(); + boolean that_present_clientIP = true && that.isSetClientIP(); + if (this_present_clientIP || that_present_clientIP) { + if (!(this_present_clientIP && that_present_clientIP)) + return false; + if (!this.clientIP.equals(that.clientIP)) + return false; + } + + boolean this_present_extraData1 = true && this.isSetExtraData1(); + boolean that_present_extraData1 = true && that.isSetExtraData1(); + if (this_present_extraData1 || that_present_extraData1) { + if (!(this_present_extraData1 && that_present_extraData1)) + return false; + if (!this.extraData1.equals(that.extraData1)) + return false; + } + + boolean this_present_extraData2 = true && this.isSetExtraData2(); + boolean that_present_extraData2 = true && that.isSetExtraData2(); + if (this_present_extraData2 || that_present_extraData2) { + if (!(this_present_extraData2 && that_present_extraData2)) + return false; + if (!this.extraData2.equals(that.extraData2)) + return false; + } + + boolean this_present_extraData3 = true && this.isSetExtraData3(); + boolean that_present_extraData3 = true && that.isSetExtraData3(); + if (this_present_extraData3 || that_present_extraData3) { + if (!(this_present_extraData3 && that_present_extraData3)) + return false; + if (!this.extraData3.equals(that.extraData3)) + return false; + } + + boolean this_present_extraInt1 = true && this.isSetExtraInt1(); + boolean that_present_extraInt1 = true && that.isSetExtraInt1(); + if (this_present_extraInt1 || that_present_extraInt1) { + if (!(this_present_extraInt1 && that_present_extraInt1)) + return false; + if (this.extraInt1 != that.extraInt1) + return false; + } + + boolean this_present_extraInt2 = true && this.isSetExtraInt2(); + boolean that_present_extraInt2 = true && that.isSetExtraInt2(); + if (this_present_extraInt2 || that_present_extraInt2) { + if (!(this_present_extraInt2 && that_present_extraInt2)) + return false; + if (this.extraInt2 != that.extraInt2) + return false; + } + + boolean this_present_extraInt3 = true && this.isSetExtraInt3(); + boolean that_present_extraInt3 = true && that.isSetExtraInt3(); + if (this_present_extraInt3 || that_present_extraInt3) { + if (!(this_present_extraInt3 && that_present_extraInt3)) + return false; + if (this.extraInt3 != that.extraInt3) + return false; + } + + boolean this_present_extraLong1 = true && this.isSetExtraLong1(); + boolean that_present_extraLong1 = true && that.isSetExtraLong1(); + if (this_present_extraLong1 || that_present_extraLong1) { + if (!(this_present_extraLong1 && that_present_extraLong1)) + return false; + if (this.extraLong1 != that.extraLong1) + return false; + } + + boolean this_present_extraLong2 = true && this.isSetExtraLong2(); + boolean that_present_extraLong2 = true && that.isSetExtraLong2(); + if (this_present_extraLong2 || that_present_extraLong2) { + if (!(this_present_extraLong2 && that_present_extraLong2)) + return false; + if (this.extraLong2 != that.extraLong2) + return false; + } + + boolean this_present_extraLong3 = true && this.isSetExtraLong3(); + boolean that_present_extraLong3 = true && that.isSetExtraLong3(); + if (this_present_extraLong3 || that_present_extraLong3) { + if (!(this_present_extraLong3 && that_present_extraLong3)) + return false; + if (this.extraLong3 != that.extraLong3) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(RequestThriftDTO other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + RequestThriftDTO typedOther = (RequestThriftDTO)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(isSetDataType()).compareTo(typedOther.isSetDataType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDataType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dataType, typedOther.dataType); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDataTime()).compareTo(typedOther.isSetDataTime()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDataTime()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dataTime, typedOther.dataTime); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetThreadCPUTime()).compareTo(typedOther.isSetThreadCPUTime()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetThreadCPUTime()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.threadCPUTime, typedOther.threadCPUTime); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetThreadUserTime()).compareTo(typedOther.isSetThreadUserTime()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetThreadUserTime()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.threadUserTime, typedOther.threadUserTime); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetRequestID()).compareTo(typedOther.isSetRequestID()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRequestID()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.requestID, typedOther.requestID); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetRequestURL()).compareTo(typedOther.isSetRequestURL()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRequestURL()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.requestURL, typedOther.requestURL); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetClientIP()).compareTo(typedOther.isSetClientIP()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetClientIP()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.clientIP, typedOther.clientIP); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraData1()).compareTo(typedOther.isSetExtraData1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraData1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraData1, typedOther.extraData1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraData2()).compareTo(typedOther.isSetExtraData2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraData2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraData2, typedOther.extraData2); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraData3()).compareTo(typedOther.isSetExtraData3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraData3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraData3, typedOther.extraData3); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraInt1()).compareTo(typedOther.isSetExtraInt1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraInt1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraInt1, typedOther.extraInt1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraInt2()).compareTo(typedOther.isSetExtraInt2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraInt2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraInt2, typedOther.extraInt2); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraInt3()).compareTo(typedOther.isSetExtraInt3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraInt3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraInt3, typedOther.extraInt3); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraLong1()).compareTo(typedOther.isSetExtraLong1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraLong1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraLong1, typedOther.extraLong1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraLong2()).compareTo(typedOther.isSetExtraLong2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraLong2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraLong2, typedOther.extraLong2); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExtraLong3()).compareTo(typedOther.isSetExtraLong3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExtraLong3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.extraLong3, typedOther.extraLong3); + 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("RequestThriftDTO("); + 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("dataType:"); + sb.append(this.dataType); + first = false; + if (!first) sb.append(", "); + sb.append("dataTime:"); + sb.append(this.dataTime); + first = false; + if (!first) sb.append(", "); + sb.append("threadCPUTime:"); + sb.append(this.threadCPUTime); + first = false; + if (!first) sb.append(", "); + sb.append("threadUserTime:"); + sb.append(this.threadUserTime); + first = false; + if (isSetRequestID()) { + if (!first) sb.append(", "); + sb.append("requestID:"); + if (this.requestID == null) { + sb.append("null"); + } else { + sb.append(this.requestID); + } + first = false; + } + if (isSetRequestURL()) { + if (!first) sb.append(", "); + sb.append("requestURL:"); + if (this.requestURL == null) { + sb.append("null"); + } else { + sb.append(this.requestURL); + } + first = false; + } + if (isSetClientIP()) { + if (!first) sb.append(", "); + sb.append("clientIP:"); + if (this.clientIP == null) { + sb.append("null"); + } else { + sb.append(this.clientIP); + } + first = false; + } + if (isSetExtraData1()) { + if (!first) sb.append(", "); + sb.append("extraData1:"); + if (this.extraData1 == null) { + sb.append("null"); + } else { + sb.append(this.extraData1); + } + first = false; + } + if (isSetExtraData2()) { + if (!first) sb.append(", "); + sb.append("extraData2:"); + if (this.extraData2 == null) { + sb.append("null"); + } else { + sb.append(this.extraData2); + } + first = false; + } + if (isSetExtraData3()) { + if (!first) sb.append(", "); + sb.append("extraData3:"); + if (this.extraData3 == null) { + sb.append("null"); + } else { + sb.append(this.extraData3); + } + first = false; + } + if (isSetExtraInt1()) { + if (!first) sb.append(", "); + sb.append("extraInt1:"); + sb.append(this.extraInt1); + first = false; + } + if (isSetExtraInt2()) { + if (!first) sb.append(", "); + sb.append("extraInt2:"); + sb.append(this.extraInt2); + first = false; + } + if (isSetExtraInt3()) { + if (!first) sb.append(", "); + sb.append("extraInt3:"); + sb.append(this.extraInt3); + first = false; + } + if (isSetExtraLong1()) { + if (!first) sb.append(", "); + sb.append("extraLong1:"); + sb.append(this.extraLong1); + first = false; + } + if (isSetExtraLong2()) { + if (!first) sb.append(", "); + sb.append("extraLong2:"); + sb.append(this.extraLong2); + first = false; + } + if (isSetExtraLong3()) { + if (!first) sb.append(", "); + sb.append("extraLong3:"); + sb.append(this.extraLong3); + 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 RequestThriftDTOStandardSchemeFactory implements SchemeFactory { + public RequestThriftDTOStandardScheme getScheme() { + return new RequestThriftDTOStandardScheme(); + } + } + + private static class RequestThriftDTOStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, RequestThriftDTO 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: // DATA_TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.dataType = iprot.readI32(); + struct.setDataTypeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // DATA_TIME + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.dataTime = iprot.readI64(); + struct.setDataTimeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // THREAD_CPUTIME + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.threadCPUTime = iprot.readI64(); + struct.setThreadCPUTimeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 6: // THREAD_USER_TIME + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.threadUserTime = iprot.readI64(); + struct.setThreadUserTimeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 7: // REQUEST_ID + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.requestID = iprot.readString(); + struct.setRequestIDIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 8: // REQUEST_URL + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.requestURL = iprot.readString(); + struct.setRequestURLIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 9: // CLIENT_IP + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.clientIP = iprot.readString(); + struct.setClientIPIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 10: // EXTRA_DATA1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.extraData1 = iprot.readString(); + struct.setExtraData1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 11: // EXTRA_DATA2 + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.extraData2 = iprot.readString(); + struct.setExtraData2IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 12: // EXTRA_DATA3 + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.extraData3 = iprot.readString(); + struct.setExtraData3IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 13: // EXTRA_INT1 + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.extraInt1 = iprot.readI32(); + struct.setExtraInt1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 14: // EXTRA_INT2 + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.extraInt2 = iprot.readI32(); + struct.setExtraInt2IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 15: // EXTRA_INT3 + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.extraInt3 = iprot.readI32(); + struct.setExtraInt3IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 16: // EXTRA_LONG1 + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.extraLong1 = iprot.readI64(); + struct.setExtraLong1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 17: // EXTRA_LONG2 + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.extraLong2 = iprot.readI64(); + struct.setExtraLong2IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 18: // EXTRA_LONG3 + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.extraLong3 = iprot.readI64(); + struct.setExtraLong3IsSet(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, RequestThriftDTO 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(); + oprot.writeFieldBegin(DATA_TYPE_FIELD_DESC); + oprot.writeI32(struct.dataType); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(DATA_TIME_FIELD_DESC); + oprot.writeI64(struct.dataTime); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(THREAD_CPUTIME_FIELD_DESC); + oprot.writeI64(struct.threadCPUTime); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(THREAD_USER_TIME_FIELD_DESC); + oprot.writeI64(struct.threadUserTime); + oprot.writeFieldEnd(); + if (struct.requestID != null) { + if (struct.isSetRequestID()) { + oprot.writeFieldBegin(REQUEST_ID_FIELD_DESC); + oprot.writeString(struct.requestID); + oprot.writeFieldEnd(); + } + } + if (struct.requestURL != null) { + if (struct.isSetRequestURL()) { + oprot.writeFieldBegin(REQUEST_URL_FIELD_DESC); + oprot.writeString(struct.requestURL); + oprot.writeFieldEnd(); + } + } + if (struct.clientIP != null) { + if (struct.isSetClientIP()) { + oprot.writeFieldBegin(CLIENT_IP_FIELD_DESC); + oprot.writeString(struct.clientIP); + oprot.writeFieldEnd(); + } + } + if (struct.extraData1 != null) { + if (struct.isSetExtraData1()) { + oprot.writeFieldBegin(EXTRA_DATA1_FIELD_DESC); + oprot.writeString(struct.extraData1); + oprot.writeFieldEnd(); + } + } + if (struct.extraData2 != null) { + if (struct.isSetExtraData2()) { + oprot.writeFieldBegin(EXTRA_DATA2_FIELD_DESC); + oprot.writeString(struct.extraData2); + oprot.writeFieldEnd(); + } + } + if (struct.extraData3 != null) { + if (struct.isSetExtraData3()) { + oprot.writeFieldBegin(EXTRA_DATA3_FIELD_DESC); + oprot.writeString(struct.extraData3); + oprot.writeFieldEnd(); + } + } + if (struct.isSetExtraInt1()) { + oprot.writeFieldBegin(EXTRA_INT1_FIELD_DESC); + oprot.writeI32(struct.extraInt1); + oprot.writeFieldEnd(); + } + if (struct.isSetExtraInt2()) { + oprot.writeFieldBegin(EXTRA_INT2_FIELD_DESC); + oprot.writeI32(struct.extraInt2); + oprot.writeFieldEnd(); + } + if (struct.isSetExtraInt3()) { + oprot.writeFieldBegin(EXTRA_INT3_FIELD_DESC); + oprot.writeI32(struct.extraInt3); + oprot.writeFieldEnd(); + } + if (struct.isSetExtraLong1()) { + oprot.writeFieldBegin(EXTRA_LONG1_FIELD_DESC); + oprot.writeI64(struct.extraLong1); + oprot.writeFieldEnd(); + } + if (struct.isSetExtraLong2()) { + oprot.writeFieldBegin(EXTRA_LONG2_FIELD_DESC); + oprot.writeI64(struct.extraLong2); + oprot.writeFieldEnd(); + } + if (struct.isSetExtraLong3()) { + oprot.writeFieldBegin(EXTRA_LONG3_FIELD_DESC); + oprot.writeI64(struct.extraLong3); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class RequestThriftDTOTupleSchemeFactory implements SchemeFactory { + public RequestThriftDTOTupleScheme getScheme() { + return new RequestThriftDTOTupleScheme(); + } + } + + private static class RequestThriftDTOTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, RequestThriftDTO 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.isSetDataType()) { + optionals.set(2); + } + if (struct.isSetDataTime()) { + optionals.set(3); + } + if (struct.isSetThreadCPUTime()) { + optionals.set(4); + } + if (struct.isSetThreadUserTime()) { + optionals.set(5); + } + if (struct.isSetRequestID()) { + optionals.set(6); + } + if (struct.isSetRequestURL()) { + optionals.set(7); + } + if (struct.isSetClientIP()) { + optionals.set(8); + } + if (struct.isSetExtraData1()) { + optionals.set(9); + } + if (struct.isSetExtraData2()) { + optionals.set(10); + } + if (struct.isSetExtraData3()) { + optionals.set(11); + } + if (struct.isSetExtraInt1()) { + optionals.set(12); + } + if (struct.isSetExtraInt2()) { + optionals.set(13); + } + if (struct.isSetExtraInt3()) { + optionals.set(14); + } + if (struct.isSetExtraLong1()) { + optionals.set(15); + } + if (struct.isSetExtraLong2()) { + optionals.set(16); + } + if (struct.isSetExtraLong3()) { + optionals.set(17); + } + oprot.writeBitSet(optionals, 18); + if (struct.isSetHostHashCode()) { + oprot.writeI32(struct.hostHashCode); + } + if (struct.isSetRequestHashCode()) { + oprot.writeI32(struct.requestHashCode); + } + if (struct.isSetDataType()) { + oprot.writeI32(struct.dataType); + } + if (struct.isSetDataTime()) { + oprot.writeI64(struct.dataTime); + } + if (struct.isSetThreadCPUTime()) { + oprot.writeI64(struct.threadCPUTime); + } + if (struct.isSetThreadUserTime()) { + oprot.writeI64(struct.threadUserTime); + } + if (struct.isSetRequestID()) { + oprot.writeString(struct.requestID); + } + if (struct.isSetRequestURL()) { + oprot.writeString(struct.requestURL); + } + if (struct.isSetClientIP()) { + oprot.writeString(struct.clientIP); + } + if (struct.isSetExtraData1()) { + oprot.writeString(struct.extraData1); + } + if (struct.isSetExtraData2()) { + oprot.writeString(struct.extraData2); + } + if (struct.isSetExtraData3()) { + oprot.writeString(struct.extraData3); + } + if (struct.isSetExtraInt1()) { + oprot.writeI32(struct.extraInt1); + } + if (struct.isSetExtraInt2()) { + oprot.writeI32(struct.extraInt2); + } + if (struct.isSetExtraInt3()) { + oprot.writeI32(struct.extraInt3); + } + if (struct.isSetExtraLong1()) { + oprot.writeI64(struct.extraLong1); + } + if (struct.isSetExtraLong2()) { + oprot.writeI64(struct.extraLong2); + } + if (struct.isSetExtraLong3()) { + oprot.writeI64(struct.extraLong3); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, RequestThriftDTO struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(18); + 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)) { + struct.dataType = iprot.readI32(); + struct.setDataTypeIsSet(true); + } + if (incoming.get(3)) { + struct.dataTime = iprot.readI64(); + struct.setDataTimeIsSet(true); + } + if (incoming.get(4)) { + struct.threadCPUTime = iprot.readI64(); + struct.setThreadCPUTimeIsSet(true); + } + if (incoming.get(5)) { + struct.threadUserTime = iprot.readI64(); + struct.setThreadUserTimeIsSet(true); + } + if (incoming.get(6)) { + struct.requestID = iprot.readString(); + struct.setRequestIDIsSet(true); + } + if (incoming.get(7)) { + struct.requestURL = iprot.readString(); + struct.setRequestURLIsSet(true); + } + if (incoming.get(8)) { + struct.clientIP = iprot.readString(); + struct.setClientIPIsSet(true); + } + if (incoming.get(9)) { + struct.extraData1 = iprot.readString(); + struct.setExtraData1IsSet(true); + } + if (incoming.get(10)) { + struct.extraData2 = iprot.readString(); + struct.setExtraData2IsSet(true); + } + if (incoming.get(11)) { + struct.extraData3 = iprot.readString(); + struct.setExtraData3IsSet(true); + } + if (incoming.get(12)) { + struct.extraInt1 = iprot.readI32(); + struct.setExtraInt1IsSet(true); + } + if (incoming.get(13)) { + struct.extraInt2 = iprot.readI32(); + struct.setExtraInt2IsSet(true); + } + if (incoming.get(14)) { + struct.extraInt3 = iprot.readI32(); + struct.setExtraInt3IsSet(true); + } + if (incoming.get(15)) { + struct.extraLong1 = iprot.readI64(); + struct.setExtraLong1IsSet(true); + } + if (incoming.get(16)) { + struct.extraLong2 = iprot.readI64(); + struct.setExtraLong2IsSet(true); + } + if (incoming.get(17)) { + struct.extraLong3 = iprot.readI64(); + struct.setExtraLong3IsSet(true); + } + } + } + +} + diff --git a/src/com/profiler/modifier/AbstractModifier.java b/src/com/profiler/modifier/AbstractModifier.java new file mode 100644 index 000000000..46fa7c3d8 --- /dev/null +++ b/src/com/profiler/modifier/AbstractModifier.java @@ -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 !!!"); + + } +} diff --git a/src/com/profiler/modifier/db/cubrid/CubridPreparedStatementModifier.java b/src/com/profiler/modifier/db/cubrid/CubridPreparedStatementModifier.java new file mode 100644 index 000000000..a3cd35242 --- /dev/null +++ b/src/com/profiler/modifier/db/cubrid/CubridPreparedStatementModifier.java @@ -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(); + + } +} diff --git a/src/com/profiler/modifier/db/cubrid/CubridResultSetModifier.java b/src/com/profiler/modifier/db/cubrid/CubridResultSetModifier.java new file mode 100644 index 000000000..14afcddc8 --- /dev/null +++ b/src/com/profiler/modifier/db/cubrid/CubridResultSetModifier.java @@ -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(); + } +} diff --git a/src/com/profiler/modifier/db/cubrid/CubridStatementModifier.java b/src/com/profiler/modifier/db/cubrid/CubridStatementModifier.java new file mode 100644 index 000000000..56e28ec95 --- /dev/null +++ b/src/com/profiler/modifier/db/cubrid/CubridStatementModifier.java @@ -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(); + + } +} diff --git a/src/com/profiler/modifier/db/cubrid/CubridUStatementModifier.java b/src/com/profiler/modifier/db/cubrid/CubridUStatementModifier.java new file mode 100644 index 000000000..a64e7170a --- /dev/null +++ b/src/com/profiler/modifier/db/cubrid/CubridUStatementModifier.java @@ -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(); + } + +} diff --git a/src/com/profiler/modifier/db/dbcp/DBCPBasicDataSourceModifier.java b/src/com/profiler/modifier/db/dbcp/DBCPBasicDataSourceModifier.java new file mode 100644 index 000000000..67c0606be --- /dev/null +++ b/src/com/profiler/modifier/db/dbcp/DBCPBasicDataSourceModifier.java @@ -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(); + } + +} diff --git a/src/com/profiler/modifier/db/dbcp/DBCPPoolModifier.java b/src/com/profiler/modifier/db/dbcp/DBCPPoolModifier.java new file mode 100644 index 000000000..94aaaecd6 --- /dev/null +++ b/src/com/profiler/modifier/db/dbcp/DBCPPoolModifier.java @@ -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(); + } +} diff --git a/src/com/profiler/modifier/db/mssql/MSSQLConnectionModifier.java b/src/com/profiler/modifier/db/mssql/MSSQLConnectionModifier.java new file mode 100644 index 000000000..8712fda8e --- /dev/null +++ b/src/com/profiler/modifier/db/mssql/MSSQLConnectionModifier.java @@ -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(); + } +} diff --git a/src/com/profiler/modifier/db/mssql/MSSQLPreparedStatementModifier.java b/src/com/profiler/modifier/db/mssql/MSSQLPreparedStatementModifier.java new file mode 100644 index 000000000..12480790c --- /dev/null +++ b/src/com/profiler/modifier/db/mssql/MSSQLPreparedStatementModifier.java @@ -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(); + + } +} diff --git a/src/com/profiler/modifier/db/mssql/MSSQLResultSetModifier.java b/src/com/profiler/modifier/db/mssql/MSSQLResultSetModifier.java new file mode 100644 index 000000000..14dda4d0c --- /dev/null +++ b/src/com/profiler/modifier/db/mssql/MSSQLResultSetModifier.java @@ -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(); + } +} diff --git a/src/com/profiler/modifier/db/mssql/MSSQLStatementModifier.java b/src/com/profiler/modifier/db/mssql/MSSQLStatementModifier.java new file mode 100644 index 000000000..c1ae65bc7 --- /dev/null +++ b/src/com/profiler/modifier/db/mssql/MSSQLStatementModifier.java @@ -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(); + + } +} diff --git a/src/com/profiler/modifier/db/mysql/MySQLConnectionImplModifier.java b/src/com/profiler/modifier/db/mysql/MySQLConnectionImplModifier.java new file mode 100644 index 000000000..6c92b2e13 --- /dev/null +++ b/src/com/profiler/modifier/db/mysql/MySQLConnectionImplModifier.java @@ -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(); + } +} diff --git a/src/com/profiler/modifier/db/mysql/MySQLPreparedStatementModifier.java b/src/com/profiler/modifier/db/mysql/MySQLPreparedStatementModifier.java new file mode 100644 index 000000000..6e882cc97 --- /dev/null +++ b/src/com/profiler/modifier/db/mysql/MySQLPreparedStatementModifier.java @@ -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(); + + } +} diff --git a/src/com/profiler/modifier/db/mysql/MySQLResultSetModifier.java b/src/com/profiler/modifier/db/mysql/MySQLResultSetModifier.java new file mode 100644 index 000000000..21ade585b --- /dev/null +++ b/src/com/profiler/modifier/db/mysql/MySQLResultSetModifier.java @@ -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(); + } +} diff --git a/src/com/profiler/modifier/db/mysql/MySQLStatementModifier.java b/src/com/profiler/modifier/db/mysql/MySQLStatementModifier.java new file mode 100644 index 000000000..80e22c689 --- /dev/null +++ b/src/com/profiler/modifier/db/mysql/MySQLStatementModifier.java @@ -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(); + + } +} diff --git a/src/com/profiler/modifier/db/oracle/OraclePreparedStatementModifier.java b/src/com/profiler/modifier/db/oracle/OraclePreparedStatementModifier.java new file mode 100644 index 000000000..51d55b30c --- /dev/null +++ b/src/com/profiler/modifier/db/oracle/OraclePreparedStatementModifier.java @@ -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(); + + } +} diff --git a/src/com/profiler/modifier/db/oracle/OracleResultSetModifier.java b/src/com/profiler/modifier/db/oracle/OracleResultSetModifier.java new file mode 100644 index 000000000..62aa335c4 --- /dev/null +++ b/src/com/profiler/modifier/db/oracle/OracleResultSetModifier.java @@ -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(); + } +} diff --git a/src/com/profiler/modifier/db/oracle/OracleStatementModifier.java b/src/com/profiler/modifier/db/oracle/OracleStatementModifier.java new file mode 100644 index 000000000..c8dc2e53e --- /dev/null +++ b/src/com/profiler/modifier/db/oracle/OracleStatementModifier.java @@ -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(); + + } +} diff --git a/src/com/profiler/modifier/tomcat/EntryPointStandardHostValveModifier.java b/src/com/profiler/modifier/tomcat/EntryPointStandardHostValveModifier.java new file mode 100644 index 000000000..11d0a2a1b --- /dev/null +++ b/src/com/profiler/modifier/tomcat/EntryPointStandardHostValveModifier.java @@ -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(); + } + } +} diff --git a/src/com/profiler/modifier/tomcat/TomcatConnectorModifier.java b/src/com/profiler/modifier/tomcat/TomcatConnectorModifier.java new file mode 100644 index 000000000..7c46a9928 --- /dev/null +++ b/src/com/profiler/modifier/tomcat/TomcatConnectorModifier.java @@ -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; + } +} diff --git a/src/com/profiler/modifier/tomcat/TomcatStandardServiceModifier.java b/src/com/profiler/modifier/tomcat/TomcatStandardServiceModifier.java new file mode 100644 index 000000000..338292c82 --- /dev/null +++ b/src/com/profiler/modifier/tomcat/TomcatStandardServiceModifier.java @@ -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; + } +} diff --git a/src/com/profiler/receiver/TCPSocketManager.java b/src/com/profiler/receiver/TCPSocketManager.java new file mode 100644 index 000000000..ff5bf5c3b --- /dev/null +++ b/src/com/profiler/receiver/TCPSocketManager.java @@ -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(); + } + } +} diff --git a/src/com/profiler/sender/AbstractDataSender.java b/src/com/profiler/sender/AbstractDataSender.java new file mode 100644 index 000000000..6f20a68e3 --- /dev/null +++ b/src/com/profiler/sender/AbstractDataSender.java @@ -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); + } +} diff --git a/src/com/profiler/sender/AgentInfoSender.java b/src/com/profiler/sender/AgentInfoSender.java new file mode 100644 index 000000000..352c27eb6 --- /dev/null +++ b/src/com/profiler/sender/AgentInfoSender.java @@ -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(); + } + } +} diff --git a/src/com/profiler/sender/JVMDataSender.java b/src/com/profiler/sender/JVMDataSender.java new file mode 100644 index 000000000..738ece85e --- /dev/null +++ b/src/com/profiler/sender/JVMDataSender.java @@ -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); + } +} diff --git a/src/com/profiler/sender/RequestDataSender.java b/src/com/profiler/sender/RequestDataSender.java new file mode 100644 index 000000000..83cd5c078 --- /dev/null +++ b/src/com/profiler/sender/RequestDataSender.java @@ -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); + } + + +} diff --git a/src/com/profiler/sender/RequestTransactionDataSender.java b/src/com/profiler/sender/RequestTransactionDataSender.java new file mode 100644 index 000000000..12d091e67 --- /dev/null +++ b/src/com/profiler/sender/RequestTransactionDataSender.java @@ -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); + } +} diff --git a/src/com/profiler/thread/AgentStateManager.java b/src/com/profiler/thread/AgentStateManager.java new file mode 100644 index 000000000..b5cca3279 --- /dev/null +++ b/src/com/profiler/thread/AgentStateManager.java @@ -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(); + } +} diff --git a/src/com/profiler/thread/CurrentJVMStateCheckThread.java b/src/com/profiler/thread/CurrentJVMStateCheckThread.java new file mode 100644 index 000000000..c523ac98a --- /dev/null +++ b/src/com/profiler/thread/CurrentJVMStateCheckThread.java @@ -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 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; + } + } +} diff --git a/src/com/profiler/trace/AbstractTracer.java b/src/com/profiler/trace/AbstractTracer.java new file mode 100644 index 000000000..999be913a --- /dev/null +++ b/src/com/profiler/trace/AbstractTracer.java @@ -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 sqlSet=null; + private static Hashtable dbConnectionURL=new Hashtable(); + static { + if(TomcatProfilerConfig.QUERY_COUNT_OVER_10000) { + sqlSet=new CopyOnWriteArraySet(); + } else { + sqlSet=new HashSet(1024); + } + } + private static final ThreadLocal requestDataThreadLocal=new ThreadLocal(); + private static final ThreadLocal> sqlParamMapThreadLocal=new ThreadLocal>(); + + /** + * These two variables are used counting "ResultSet.next()" times. + */ + private static final ThreadLocal fetchCountThreadLocal=new ThreadLocal(); + private static final ThreadLocal totalFetchCountThreadLocal=new ThreadLocal(); + 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 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 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 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 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 list) { + if(isRequestData()) { + HashMap 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 map=sqlParamMapThreadLocal.get(); + if(map==null) { + map=new HashMap(); + } +// 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()); + } + 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 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); + } + } + } +} diff --git a/src/com/profiler/trace/RequestTransactionTracer.java b/src/com/profiler/trace/RequestTransactionTracer.java new file mode 100644 index 000000000..1edc58fed --- /dev/null +++ b/src/com/profiler/trace/RequestTransactionTracer.java @@ -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 requestTable=new Hashtable(); + private static Set requestSet=null; + static{ + requestSet=Collections.synchronizedSet(new HashSet()); + } + + public RequestTransactionTracer() { + } + private static final ThreadLocal requestID=new ThreadLocal(); + private static final ThreadLocal requestHashCode=new ThreadLocal(); + 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; + } + */ +} diff --git a/src/com/profiler/util/QueryStringUtil.java b/src/com/profiler/util/QueryStringUtil.java new file mode 100644 index 000000000..6ac87c5df --- /dev/null +++ b/src/com/profiler/util/QueryStringUtil.java @@ -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; + } +}