Documente Academic
Documente Profesional
Documente Cultură
0
Install Guide
Chapter 1 – Platform Support
JXInsight is relatively easy to install into an existing J2EE™ application. The integration of the server-side part of the product
into a J2EE™ application server is as easy as installing a JDBC driver into the same environment.
Platform Support
JXInsight and JVMPI Agent
Windows NT 4.0, Windows 2000 Professional, Windows 2000 Advanced Server, Windows XP
Solaris and Linux (RedHat, Suse)
Mac OSX, AIX and HP-UX
JDK 1.4.x, JDK 1.3.x
JXInsight Console
Windows NT 4.0, Windows 2000 Professional, Windows 2000 Advanced Server, Windows XP
Solaris and Linux (RedHat, Suse)
Mac OSX, AIX and HP-UX
JDK 1.4.x (please use product installed JRE 1.4.2 when provided)
JXInsight Terminal
Windows NT 4.0, Windows 2000 Professional, Windows 2000 Advanced Server, Windows XP
Solaris and Linux (RedHat, Suse)
Mac OSX, AIX and HP-UX
JDK 1.4.x (please use product installed JRE – 1.4.2)
Application Servers
BEA Weblogic Server 5.x, 6.x, 7.x, 8.x and 9.0
IBM Websphere 3.5, 4.0, 5.x and 6.0
Oracle (OCJ) 9.x/10.x
JBoss 2.44, 3.0 and 4.0
Pramati 3.x
Borland Entreprise Server BAS 4.x, BES 5.x/6.x
Apache Tomcat
Resin
In general the product should work with most web and component application server products
Database
Oracle
DB2
Sybase
Informix
SQL Server
Borland JDataStore
Cloudscape
PointBase
In general the product should work with most SQL/92 database products supporting the JDBC standard
Page 1 of 47
Java Libraries
Recommendation: Deploy the jxinsight-core.jar into the application server’s library path. Those extensions that are part of
the application server’s runtime should also be deployed into the server’s library path. For technologies such as JDO, Spring,
JCR, and Hibernate which are deployed as libraries in a the web-inf/lib directory copy the extension(s) into the same directory
or update the web archive with the extension.
jxinsight-all.jar
All classes from jxinsight-core.jar, jxinsight-ext-*.jar and jxinsight-jdbc-drivers.jar.
jxinsight-core.jar
JXInsight Tracer and Profiler and JSE trace extensions (JDBC, CORBA, JNDI, RMI, JMX)
jxinsight-jdbc-drivers.jar
JDBInsight JDBC Drivers and DataSources
jxinsight-ext-j2ee.jar
J2EE trace extensions (JMS, JCA, EJB, JTS, JTA, Servlets/JSP, JAX-RPC)
jxinsight-ext-jcr.jar
Java Content Repository (JCR) trace extension
jxinsight-ext-vbj.jar
Borland VisiBroker (distributed) trace extension
jxinsight-ext-kodo.jar
SolarMetric Kodo JDO trace extension
jxinsight-ext-jboss.jar
JBoss EJB (distributed) trace extension
jxinsight-ext-ant.jar
Apache Ant trace extension
jxinsight-ext-junit.jar
JUnit trace extension
jxinsight-ext-jdo.jar
JDO trace extension
jxinsight-ext-hibernate.jar
Hibernate 3.0 and 2.0 trace extensions
jxinsight-ext-ejb3.jar
EJB3 trace extension (Note: The EJB3 trace extension is not included in jxinsight-ext-j2ee.jar)
jxinsight-ext-commonj.jar
commonj WorkManager and TimerManager trace extensions
jxinsight-ext-spring.jar
Spring Framework AOP based Trace Interceptor
jxinsight-ext-hpovobs.jar
HP OpenView OBS TraceInterceptor
Page 2 of 47
Chapter 2 - JVMPI Agent
JXInsight requires the installation of a native library, jdbinsight.(dll | so | sl), which integrates into the JVM’s Profiling Interface
(JVMPI). The library needs to be installed on the native library path of the application server JVM process. To install the
library on the library path this might require changing the servers start up script, changing the system environment or copying
the native agent library into an existing directory on the library path.
The native library can be loaded on JVM start-up by specify –Xrunjdbinsight on the command line executing the Java process
creation call.
The –Xrun allows various flags to be passed to the agent, which turn on or off various counters. Configurable counters include
GC (g), Object Allocations (a), Blocking (b) and Waiting (w). To turn on GC simply specify –Xrunjdbinsight:g=t. To turn off the
blocking counter –Xrunjdbinsight:b=f. By default Blocking and Waiting counters are turned on. Multiple flags can be turn on and
off by separating flags with a comma. For example to turn off Waiting and Blocking –Xrunjdbinsight:b=f,w=f.
Page 3 of 47
Chapter 3 - JDBInsight JDBC Driver and DataSources
JDBInsight is basically a driver that wraps around an existing JDBC driver/datasource, intercepting calls and analyzing the data.
The driver will also plug into the VM profiler interface (JVMPI). The level of interaction with the profiler interface is kept to a
minimum to ensure that JDBInsight does not incur the same high level of overhead found in Java code profiler products.
This means, that no changes are required to an existing J2EE™ application source code (unless the JDBC connection strings
have been hard-coded within source code, which is not recommended practice). Also the byte code of the underlying JDBC
driver will not be changed by a class loader for instrumentation purposes. In general, the only small change that needs to be
done is in the reconfiguration of connection pools or datasources.
The changes required are in the specification of the driver class name and connection URL. The class name value should
change to one of the following:
a) com.jinspired.jdbinsight.drivers.jdbc1x.Driver
b) com.jinspired.jdbinsight.drivers.jdbc1w2.ConnectionPoolDataSource
With options (a) and (b) the URL should have ‘jdbinsight:’ inserted after the initial jdbc: URL specification such as
“jdbc:jdbinsight:oracle:thin:@xxxx”.
c) com.jinspired.jdbinsight.drivers.jdbc1x.OracleDriver
Option (c) instead should have “orainsight” inserted such as “jdbc:orainsight:oracle:thin:@xxxx”. Currently we are using the
‘orainsight:’ prefix to differentiate between providing a standard compliant interface and an oracle proprietary interface one. If a
J2EE application does not rely on Oracle specific JDBC API extensions then use option (a) or (b).
d) com.jinspired.jdbinsight.drivers.jdbc2.ConnectionPoolDataSource
Options (d) is used to proxy an existing JNDI deployed connection pool datasource. The (e) datasource has a JavaBeans
property “dataSourceName” - setDataSourceName(String jndiname). The installation of this datasource requires the pointing of
the Application Server container connection pool to the JDBInsight datasource and pointing the JDBInsight datasource to the
driver specific datasource. The JDBInsight datasource will simply delegate calls for pooled connections to the driver specific
datasource. Thus both the JDBInsight and driver specific datasource need to be deployed into the JNDI.
e) com.jinspired.jdbinsight.drivers.jdbc2.DataSource
f) com.jinspired.jdbinsight.drivers.jdbc2.OracleConnectionPoolDataSource
Options (f) to (i) provide datasources which have the same JavaBeans property set of the Oracle specific datasources. Thus the
only change that should be made to an existing JNDI deployed datasource is in the datasource class name. The property
configuration should be exactly the same. Options (f) to (i) should be used when the datasource clients require access to
connections and statements which implement interfaces in the oracle.jdbc.* package.
g) com.jinspired.jdbinsight.drivers.jdbc2.oracle9i.OracleConnectionPoolDataSource
h) com.jinspired.jdbinsight.drivers.jdbc2.oracle9i.OracleDataSource
i) com.jinspired.jdbinsight.drivers.jdbc2.oracle10g.OracleXADataSource
Only use the oracle9i/oracle10g DataSource class if you are using specific data source properties not found in the standard
Oracle DataSource proxy.
j) com.jinspired.jdbinsight.drivers.jdbc2.PropertiesConnectionPoolDataSource
k) com.jinspired.jdbinsight.drivers.jdbc2.PropertiesXAPoolDataSource
Option (j) and (k) should be used for app server products such as Websphere 5.0, which do not make a distinction, in terms of
JNDI deployments, between a configured vendor specific connection pool datasource (connection factory) and a connection
pool (app server managed). PropertiesConnectionPoolDataSource and PropertiesXADataSource both load the configuration of a
vendor connection pool or XA datasource class from a properties file located at a configured URL. Both have the following bean
properties (setXXX) that can be configured in an application server’s admin console:
• driverClassName (setDriverClassName(String)): A string property specifying the vendor specific CPDS or XADS class
such as COM.ibm.db2.jdbc.DB2ConnectionPoolDataSource.
• url (setUrl(String)): A string property specifying the URL of a standard properties file. For local file system usage the
URL should be specified like file:///c:/datasources/ds1.properties. The properties file should contain
name=value lines representing the configuration (set calls) to be performed on an instance of the vendor specific
Page 4 of 47
CPDS/XADS class. If the CPDS/XADS class has methods setDatabaseName, setUser, and setPassword then the
properties file should look like
databaseName=db2db
user=myusername
password=mypassword
The datasource class will prefix each property name with 'set' and capitalize the first letter of the original property
name. All properties are invoked on the vendor CPDS/XADS before the first request to get a pooled connection is
called.
• dialect (setDialect(String)): Supports the ability to return specific vendor JDBC classes. Currently the only dialect
implemented is 'oracle' which will return JDBC objects implementing Oracle JDBC API extensions.
l) com.jinspired.jdbinsight.drivers.jdbc2.DB2jConnectionPoolDataSource
Proxy for com.ibm.db2j.jdbc.DB2jConnectionPoolDataSource instances
m) com.jinspired.jdbinsight.drivers.jdbc2.DB2jXADataSource
Proxy for com.ibm.db2j.jdbc.DB2jXADataSource instances
n) com.jinspired.jdbinsight.drivers.jdbc2.PointBaseDataSource
Proxy for com.pointbase.jdbc.jdbcDataSource instances
o) com.jinspired.jdbinsight.drivers.jdbc2.PointBaseXADataSource
Proxy for com.pointbase.xa.xaDataSource instances
p) com.jinspired.jdbinsight.drivers.jdbc2.WebLogicOracleXADataSource
Proxy for weblogic.jdbcx.oracle.OracleDataSource
q) com.jinspired.jdbinsight.drivers.jdbc2.OracleXADataSource
Proxy for Oracle XA DataSource instances
r) com.jinspired.jdbinsight.drivers.jdbc2.TdsDataSource
s) com.jinspired.jdbinsight.drivers.jdbc2.TdsPDataSource
Proxy for i-Net Opta DataSource instances
Page 5 of 47
Generic Application Server Example (A)
change to
<datasource>
<url>jdbc:jdbinsight:oracle:thin:@hostname:1521:ORACLE</url>
<driver-class-name>com.jinspired.jdbinsight.drivers.jdbc1x.Driver</driver-class-name>
</datasource>
change to
<datasource>
<url>jdbc:jdbinsight:HypersonicSQL:hsql://localhost</url>
<driver-class-name>com.jinspired.jdbinsight.drivers.jdbc1x.Driver</driver-class-name>
</datasource>
change to
<datasource>
<url>jdbc:jdbinsight:oracle:thin:@hostname:1521:ORACLE</url>
<driver-class-name>com.jinspired.jdbinsight.drivers.jdbc1x.OracleDriver</driver-class-name>
</datasource>
Page 6 of 47
BEA Weblogic Example (A)
Change to
<JDBCConnectionPool CapacityIncrement="1"
DriverName="com.jinspired.jdbinsight.drivers.jdbc1x.Driver"
InitialCapacity="40" MaxCapacity="40"
Name="ecperfConnectionPool" PreparedStatementCacheSize="300"
Properties="user=username;password=password;protocol=thin"
Targets="ecperfserver" URL="jdbc:jdbinsight:oracle:thin:@localhost:1521:JINSPIRED"/>
Change to
<JDBCConnectionPool CapacityIncrement="1"
DriverName="com.jinspired.jdbinsight.drivers.jdbc1x.Driver"
InitialCapacity="40" MaxCapacity="40"
Name="ecperfConnectionPool" PreparedStatementCacheSize="300"
Properties="user=username;password=password;protocol=thin"
Targets="ecperfserver" URL="jdbc:jdbinsight:oracle:thin:@localhost:1521:JINSPIRED"/>
Change to
<JDBCConnectionPool
DriverName=" com.jinspired.jdbinsight.drivers.jdbc1x.Driver"
Name="MyPool" Password="" Properties="user=sa"
Targets="torpedo" TestConnectionsOnCreate="false"
TestConnectionsOnRelease="false"
TestConnectionsOnReserve="false"
TestTableName=""
URL="jdbc:jdbinsight:HypersonicSQL:hsql://localhost"/>
<JDBCTxDataSource JNDIName="AuctionDataSource" Name="ADS"
PoolName="MyPool" Targets="torpedo"/>
Page 7 of 47
Apache Tomcat 4.0
<parameter>
<name>factory</name>
<value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
</parameter>
</ResourceParams>
Page 8 of 47
IBM WebSphere Example (B)
JDBC 2 DataSource
<resourceProviders xmi:type=”resources:JDBCDriver” xmi:id=”JDBCDriver_3” name=”JDBInsightJDBC Driver”
description=”Custom JDBC2.0-compliant driver configuration”
implementationClassName=”oracle.jdbc.pool.OracleConnectionPoolDataSource”>
<urlPrefix xsi:nil=”true”/>
<factories xmi:type=”resources:DataSource” xmi:id=”DataSource_5” name=”OracleDataSource”
jndiName=”ps/OracleDatasource” jtaEnabled=”false” statementCacheSize=”100” defaultUser=”system”
defaultPassword=”{xor}Mj4xPjg6LQ==” disableAutoConnectionCleanup=”false”>
<propertySet xmi:id=”J2EEResourcePropertySet_2”>
<resourceProperties xmi:id=”J2EEResourceProperty_4” name=”url” type=”java.lang.String”
value=”jdbc:oracle:thin:@localhost:1521:oracle” description=”Database url”/>
</propertySet>
</factories>
<propertySet xmi:id=”J2EEResourcePropertySet_1”/>
</resourceProviders>
Change to
Page 9 of 47
JBoss Example (B)
Change to
Change to
<datasources>
<local-tx-datasource>
<jndi-name>jdbc/DS</jndi-name>
<driver-class>com.jinspired.jdbinsight.drivers.jdbc1x.Driver</driver-class>
<user-name>username</user-name>
<password>password</password>
<exception-sorter-class-name>org.jboss.resource.adapter.jdbc.vendor.SybaseExceptionSorter</exception-sorter-class-name>
<connection-url>jdbc:jdbinsight:sybase:Tds:db:5010/db?APPLICATIONNAME=JBoss&HOSTNAME=host</connection-
url>
</local-tx-datasource>
</datasources>
Page 10 of 47
Orion and OC4J Examples (G)
Change to
<data-source
class="com.evermind.sql.DriverManagerDataSource"
name="OracleDS2"
location="jdbc/OracleCoreDS2"
xa-location="jdbc/xa/OracleXADS2"
ejb-location="jdbc/adventure/AdventureDB"
connection-driver="com.jinspired.jdbinsight.drivers.jdbc1x.Driver"
username="wl_perf_cr3"
password="wl_perf_cr3"
url="jdbc:jdbinsight:oracle:thin:@xxxxxx:1521:xxxx"
inactivity-timeout="30"
/>
Change to
<data-source
class="com.jinspired.jdbinsight.drivers.jdbc2.OracleConnectionPoolDataSource"
name="Oracle" location="jdbc/OracleCoreDS" xa-location="jdbc/xa/OracleCoreDS" ejb-location="jdbc/OracleDS"
inactivity-timeout="30" schema="database-schemas/oracle.xml" min-connections="10" max-connections="10">
<property name="user" value="SYSTEM"/>
<property name="password" value="MANAGER"/>
<property name="url" value="jdbc:oracle:thin:@192.168.0.1:1521:ORACLE"/>
</data-source>
Page 11 of 47
Borland Enterprise Server (G)
<driver-datasource>
<jndi-name>serial://datasources/oraclecpds</jndi-name>
<datasource-class-name>oracle.jdbc.pool.OracleConnectionPoolDataSource</datasource-class-name>
<property>
<prop-name>user</prop-name>
<prop-type>String</prop-type>
<prop-value>SYSTEM</prop-value>
</property>
<property>
<prop-name>password</prop-name>
<prop-type>String</prop-type>
<prop-value>MANAGER</prop-value>
</property>
<property>
<prop-name>databaseName</prop-name>
<prop-type>String</prop-type>
<prop-value>ORACLE</prop-value>
</property>
<property>
<prop-name>serverName</prop-name>
<prop-type>String</prop-type>
<prop-value>192.168.0.1</prop-value>
</property>
<property>
<prop-name>portNumber</prop-name>
<prop-type>Integer</prop-type>
<prop-value>1521</prop-value>
</property>
<property>
<prop-name>driverType</prop-name>
<prop-type>String</prop-type>
<prop-value>thin</prop-value>
</property>
</driver-datasource>
Change to
<driver-datasource>
<jndi-name>serial://datasources/oraclecpds</jndi-name>
<datasource-class-name>com.jinspired.jdbinsight.drivers.jdbc2.OracleConnectionPoolDataSource</datasource-
class-name>
<property>
<prop-name>user</prop-name>
<prop-type>String</prop-type>
<prop-value>SYSTEM</prop-value>
</property>
<property>
<prop-name>password</prop-name>
<prop-type>String</prop-type>
<prop-value>MANAGER</prop-value>
</property>
<property>
<prop-name>databaseName</prop-name>
<prop-type>String</prop-type>
<prop-value>ORACLE</prop-value>
</property>
<property>
<prop-name>serverName</prop-name>
<prop-type>String</prop-type>
<prop-value>192.168.0.1</prop-value>
</property>
<property>
<prop-name>portNumber</prop-name>
<prop-type>Integer</prop-type>
<prop-value>1521</prop-value>
</property>
…
</driver-datasource>
Page 12 of 47
Borland Enterprise Server (E)
<visitransact-datasource>
<jndi-name>serial://datasources/com.acme.pkc.datasource</jndi-name>
<driver-datasource-jndiname>serial://datasources/drivercom.acme.pkc.datasource</driver-datasource-jndiname>
…
</visitransact-datasource>
<driver-datasource>
<jndi-name>serial://datasources/drivercom.acme.pkc.datasource</jndi-name>
<datasource-class-name>com.informix.jdbcx.IfxConnectionPoolDataSource</datasource-class-name>
….
</driver-datasource>
</jndi-definitions>
Change to
<jndi-definitions>
<visitransact-datasource>
<jndi-name>serial://datasources/com.acme.pkc.datasource</jndi-name>
<driver-datasource-jndiname>serial://datasources/jinspired</driver-datasource-jndiname>
…
</visitransact-datasource>
<driver-datasource>
<jndi-name>serial://datasources/jinspired</jndi-name>
<datasource-class-name>com.jinspired.jdbinsight.drivers.jdbc2.ConnectionPoolDataSource</datasource-class-name>
<log-writer>false</log-writer>
<property>
<prop-name>dataSourceName</prop-name>
<prop-type>String</prop-type>
<prop-value>serial://datasources/drivercom.acme.pkc.datasource</prop-value>
</property>
</driver-datasource>
<driver-datasource>
<jndi-name>serial://datasources/drivercom.acme.pkc.datasource</jndi-name>
<datasource-class-name>com.informix.jdbcx.IfxConnectionPoolDataSource</datasource-class-name>
….
</driver-datasource>
</jndi-definitions>
Depending on the application server and the underlying JDBC driver, it might also be a requirement to specify a standard VM
property listing driver classes to be instantiated by the java.sql.DriverManager class on the command line of an application
server start-up script. For the above-mentioned example, this would be
-Djdbc.drivers=oracle.jdbc.driver.OracleDriver.
This is typically required when the JDBInsight driver does not recognize the driver specific URL or the appserver connection pool
facility is not aware of the underlying driver class that needs to be installed. For ease of use JDBInsight has an internal mapping
mechanism of URL to Driver class.
For those customers whose application server requires a JDBC 2 javax.sql.DataSource there is an implementation class named
com.jinspired.jdbinsight.drivers.jdbc1w2.ConnectionPoolDataSource that simply wraps around the a vendor JDBC 1.x driver
implementation. Currently this is a very primitive implementation with hardly any customizations (resources constraints)
expected of a proper connection pool implementation.
Please consult an application server’s documentation with regard to the installation of JDBC driver libraries into their respective
environment classpath.
Page 13 of 47
Chapter 4 – JXInsight Trace Extensions
1. Include either jxinsight-all.jar or both jxinsight-core.jar and jxinsight-ext-vbj.jar on the classpath of the Java process.
2. Specify the JVM parameter (see install guide for additional library command options) -Xrunjdbinsight
3. Specify the JVM system property –Dvbroker.orb.dynamicLibs=com.jinspired.jxinsight.trace.ext.visibroker.ServiceLoader
Traces started on the client process will be transferred to the server process and appended to the trace root before server
dispatching. Creating a cluster of servers and clients and taking a snapshot will allow for distributed profiling and tracing within
the console. The above screenshot shows the tracing of a CORBA client call from process [3960] into process [2364] the current
thread traces within the client are transferred to the server and appended to the root trace path. Distributed traces are
enclosed within < and > brackets.
The interceptor can be configured to delimit a request trace into distinct trace identifiers, providing grouping and aggregation of
statistics. Variables must be delimited by a comma. The list of possible variables is:
${visibroker.protocol}
${visibroker.typeid}
${visibroker.operation}
${trace.timestamp}
Note: Plain text values (no spaces) may also be referenced in the list.
Page 14 of 47
Servlet/JSP Trace Extension [jxinsight-ext-j2ee.jar]
JXInsight supports profiling of Servlet/JSP via an implementation of javax.servlet.Filter. The following changes made to a
web.xml file will result in profiling at the jsp level.
<filter>
<filter-name>jxinsight</filter-name>
<filter-class>com.jinspired.jxinsight.trace.ext.servlet.TraceFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>jxinsight</filter-name>
<url-pattern>*.jsp</url-pattern>
</filter-mapping>
The servlet filter can be configured to delimit a servlet trace into distinct trace identifiers using the following initialization
parameter
<filter>
<filter-name>jxinsight</filter-name>
<filter-class>com.jinspired.jxinsight.trace.ext.servlet.TraceFilter</filter-class>
<init-param>
<param-name>trace.identifiers</param-name>
<param-value>${servlet.protocol},${servlet.method},${servlet.url}</param-value>
</init-param>
</filter>
${servlet.protocol}
${servlet.remotehost}
${servlet.remoteaddress}
${servlet.method}
${servlet.port}
${servlet.querystring}
${servlet.sessionid}
${trace.timestamp}
${servlet.url}
${servlet.uri}
${servlet.contextpath}
${servlet.pathinfo}
${servlet.servletpath}
${servlet.user}
${servlet.authtype}
Page 15 of 47
CORBA PortableInterceptors Trace Extension [jxinsight-core.jar]
A trace extension enabling distributed tracing across multiple CORBA (IBM, BEA, Borland, and IONA) compliant products having support
for portable interceptors. To enable tracing add the following system property to both client and server processes
-Dorg.omg.PortableInterceptor.ORBInitializerClass.com.jinspired.jxinsight.trace.ext.corba.ORBInitializer
The /samples/corba directory contains a working example of the extension using the standard Java ORB that ships with JDK 1.4. Steps
to running the example
The interceptor can be configured to delimit a request trace into distinct trace identifiers, providing grouping and aggregation of
statistics. Variables must be delimited by a comma. The list of possible variables is:
${corba.requestid}
${corba.operation}
${trace.timestamp}
${corba.protocol}
Page 16 of 47
EJB Trace Extension [jxinsight-ext-j2ee.jar]
The EJB trace extension enables profiling and tracing of inter JVM invocations on EJBHome, EJBLocalHome, EJBObject and
EJBLocalObject instances across component boundaries (interfaces). By default session homes, session beans and entity homes
retrieved via a lookup call on a javax.naming.InitialContext instance will be proxied with profile tracing of all dispatched invocations for
declared interfaces.
To enable or disable the JXInsight trace extension for EJB specify the following system property:
There are additional properties for enabling or disabling profile tracing based on the component type:
The EJB trace extension can be configured to delimit a trace into distinct trace identifiers using the following system properties
jxinsight.server.tracer.ext.ejb.object.remote.trace.identifiers=${ejbobject.jndi},${ejbobject.operation}
jxinsight.server.tracer.ext.ejb.object.local.trace.identifiers=${ejbobject.jndi},${ejbobject.operation}
jxinsight.server.tracer.ext.ejb.home.remote.trace.identifiers=${ejbhome.jndi},,${ejbhome.operation}
jxinsight.server.tracer.ext.ejb.home.local.trace.identifiers=${ejbhome.jndi},${ejbhome.operation}
Variables must be delimited by a comma. The list of possible variables for EJBHome traces are:
${ejbhome.jndi}
${ejbhome.codesource}
${ejbhome.package}
${ejbhome.classname}
${ejbhome.fullclassname}
${ejbhome.operation}
${ejbobject.jndi}
${ejbobject.codesource}
${ejbobject.package}
${ejbobject.classname}
${ejbobject.fullclassname}
${ejbobject.operation}
${trace.timestamp}
Note: Plain text values (no spaces) may also be referenced in the list of variables.
Page 17 of 47
JTA Trace Extension [jxinsight-ext-j2ee.jar]
The JTA Trace extension profiles invocations on JTA UserTransaction instances retrieved via a JNDI InitialContext lookup
System properties associated with this extension include:
jxinsight.server.tracer.ext.proxy.jta.usertransaction.onlyjavacompenv=false
jxinsight.server.tracer.ext.proxy.jta.usertx.invoke.optimization.enabled=true
jxinsight.server.tracer.ext.proxy.jta.enabled=true
jxinsight.server.tracer.ext.proxy.jta.usertx.enabled=true
The trace extension can be configured to delimit a trace into distinct trace identifiers using the following system (default shown)
-Djxinsight.server.tracer.ext.proxy.jta.usertx.trace.identifiers=${jta.usertx.jndi},${jta.usertx.operation}
Variables must be delimited by a comma. The list of possible variables for JTA traces are:
${jta.usertx.jndi}
${jta.usertx.classname}
${jta.usertx.operation}
${jta.usertx.method}
${jta.usertx.codesource}
${jta.usertx.package}
${jta.usertx.fullclassname}
To disable this extension add the following system property to the servers JVM command line
-Djxinsight.server.tracer.ext.proxy.jta.enabled=false
Page 18 of 47
JMS Trace Extension [jxinsight-ext-j2ee.jar]
The JMS Trace extension profiles invocations on objects implementing interfaces defined in the JMS package javax.jms.*. The
connection factory (entry point) must be retrieved via a JNDI lookup. JXInsight will only proxy instances created via invocations
on retrieved connection factory instances.
To enable or disable the JXInsight trace extension for JMS specify the following system property (default is true):
-Djxinsight.server.tracer.ext.jms.proxy.enabled=true
The following system properties relate to javax.jms.ConnectionFactory objects retrieved via JNDI lookup calls.
jxinsight.server.tracer.ext.jms.connectionfactory.trace.enabled=true
jxinsight.server.tracer.ext.jms.connectionfactory.topic.trace.enabled=true
jxinsight.server.tracer.ext.jms.connectionfactory.queue.trace.enabled=true
jxinsight.server.tracer.ext.jms.connectionfactory.topic.xa.trace.enabled=true
jxinsight.server.tracer.ext.jms.connectionfactory.queue.xa.trace.enabled=true
jxinsight.server.tracer.ext.jms.connectionfactory.proxy.enabled=true
jxinsight.server.tracer.ext.jms.connectionfactory.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jms.connectionfactory.topic.proxy.enabled=true
jxinsight.server.tracer.ext.jms.connectionfactory.queue.proxy.enabled=true
jxinsight.server.tracer.ext.jms.connectionfactory.topic.xa.proxy.enabled=true
jxinsight.server.tracer.ext.jms.connectionfactory.queue.xa.proxy.enabled=true
The following system properties relate to javax.jms.Connection objects created by proxied javax.jms.ConnectionFactory
instances.
jxinsight.server.tracer.ext.jms.connection.trace.enabled=true
jxinsight.server.tracer.ext.jms.connection.topic.trace.enabled=true
jxinsight.server.tracer.ext.jms.connection.queue.trace.enabled=true
jxinsight.server.tracer.ext.jms.connection.topic.xa.trace.enabled=true
jxinsight.server.tracer.ext.jms.connection.queue.xa.trace.enabled=true
jxinsight.server.tracer.ext.jms.connection.proxy.enabled=true
jxinsight.server.tracer.ext.jms.connection.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jms.connection.topic.proxy.enabled=true
jxinsight.server.tracer.ext.jms.connection.queue.proxy.enabled=true
jxinsight.server.tracer.ext.jms.connection.topic.xa.proxy.enabled=true
jxinsight.server.tracer.ext.jms.connection.queue.xa.proxy.enabled=true
Page 19 of 47
jxinsight.server.tracer.ext.jms.browser.trace.enabled=true
jxinsight.server.tracer.ext.jms.serversession.trace.enabled=true
jxinsight.server.tracer.ext.jms.sessionpool.trace.enabled=true
jxinsight.server.tracer.ext.jms.browser.proxy.enabled=true
jxinsight.server.tracer.ext.jms.serversession.proxy.enabled=true
jxinsight.server.tracer.ext.jms.sessionpool.proxy.enabled=true
jxinsight.server.tracer.ext.jms.browser.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jms.serversession.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jms.sessionpool.proxy.onlyjavacompenv=false
The following system properties relate to javax.jms.MessageConsumer objects created by proxied javax.jms.Session instances.
jxinsight.server.tracer.ext.jms.consumer.trace.enabled=true
jxinsight.server.tracer.ext.jms.consumer.topic.trace.enabled=true
jxinsight.server.tracer.ext.jms.consumer.queue.trace.enabled=true
jxinsight.server.tracer.ext.jms.consumer.proxy.enabled=true
jxinsight.server.tracer.ext.jms.consumer.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jms.consumer.topic.proxy.enabled=true
jxinsight.server.tracer.ext.jms.consumer.queue.proxy.enabled=true
The following system properties relate to javax.jms.MessageProducer objects created by proxied javax.jms.Session instances.
jxinsight.server.tracer.ext.jms.producer.trace.enabled=true
jxinsight.server.tracer.ext.jms.producer.queue.trace.enabled=true
jxinsight.server.tracer.ext.jms.producer.topic.trace.enabled=true
jxinsight.server.tracer.ext.jms.producer.proxy.enabled=true
jxinsight.server.tracer.ext.jms.producer.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jms.producer.queue.proxy.enabled=true
jxinsight.server.tracer.ext.jms.producer.topic.proxy.enabled=true
The following system properties relate to javax.jms.Message objects created by proxied javax.jms.Session instances.
jxinsight.server.tracer.ext.jms.message.trace.enabled=true
jxinsight.server.tracer.ext.jms.message.bytes.trace.enabled=true
jxinsight.server.tracer.ext.jms.message.map.trace.enabled=true
jxinsight.server.tracer.ext.jms.message.object.trace.enabled=true
jxinsight.server.tracer.ext.jms.message.stream.trace.enabled=true
jxinsight.server.tracer.ext.jms.message.text.trace.enabled=true
jxinsight.server.tracer.ext.jms.message.proxy.enabled=true
jxinsight.server.tracer.ext.jms.message.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jms.message.bytes.proxy.enabled=true
jxinsight.server.tracer.ext.jms.message.map.proxy.enabled=true
jxinsight.server.tracer.ext.jms.message.object.proxy.enabled=true
jxinsight.server.tracer.ext.jms.message.stream.proxy.enabled=true
jxinsight.server.tracer.ext.jms.message.text.proxy.enabled=true
jxinsight.server.tracer.ext.jms.messagelistener.trace.enabled=true
jxinsight.server.tracer.ext.jms.exceptionlistener.trace.enabled=true
The following system properties relate to javax.jms.TemporaryTopic and javax.jms.TemporaryQueue objects created by proxied
javax.jms.Session instances.
jxinsight.server.tracer.ext.jms.destination.trace.enabled=true
jxinsight.server.tracer.ext.jms.destination.topic.temporary.trace.enabled=true
jxinsight.server.tracer.ext.jms.destination.queue.temporary.trace.enabled=true
jxinsight.server.tracer.ext.jms.destination.proxy.enabled=true
jxinsight.server.tracer.ext.jms.destination.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jms.destination.topic.temporary.proxy.enabled=true
jxinsight.server.tracer.ext.jms.destination.queue.temporary.proxy.enabled=true
The following system properties relate to javax.jms.Session objects created by proxied javax.jms.Connection instances.
jxinsight.server.tracer.ext.jms.session.trace.enabled=true
jxinsight.server.tracer.ext.jms.session.topic.trace.enabled=true
jxinsight.server.tracer.ext.jms.session.queue.trace.enabled=true
jxinsight.server.tracer.ext.jms.session.topic.xa.trace.enabled=true
jxinsight.server.tracer.ext.jms.session.queue.xa.trace.enabled=true
jxinsight.server.tracer.ext.jms.session.proxy.enabled=true
Page 20 of 47
jxinsight.server.tracer.ext.jms.session.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jms.session.topic.proxy.enabled=true
jxinsight.server.tracer.ext.jms.session.queue.proxy.enabled=true
jxinsight.server.tracer.ext.jms.session.topic.xa.proxy.enabled=true
jxinsight.server.tracer.ext.jms.session.queue.xa.proxy.enabled=true
The JMS trace extension can be configured to delimit a trace into distinct trace identifiers using the following system properties
jxinsight.server.tracer.ext.jms.connection.trace.identifiers=${jms.connection.jndi},${jms.connection.operation}
jxinsight.server.tracer.ext.jms.connectionfactory.trace.identifiers=${jms.connectionfactory.jndi},${jms.connectionfactory.operation}
jxinsight.server.tracer.ext.jms.consumer.trace.identifiers=${jms.consumer.jndi},${jms.consumer.operation}
jxinsight.server.tracer.ext.jms.destination.trace.identifiers=${jms.destination.jndi},${jms.destination.operation}
jxinsight.server.tracer.ext.jms.exceptionlistener.trace.identifiers=${jms.exceptionlistener.jndi},${jms.exceptionlistener.operation}
jxinsight.server.tracer.ext.jms.message.trace.identifiers=${jms.message.jndi},${jms.message.operation}
jxinsight.server.tracer.ext.jms.messagelistener.trace.identifiers=${jms.messagelistener.jndi},${jms.messagelistener.destination},${jms.
messagelistener.operation}
jxinsight.server.tracer.ext.jms.producer.trace.identifiers=${jms.producer.jndi},${jms.producer.operation}
jxinsight.server.tracer.ext.jms.browser.trace.identifiers=${jms.browser.jndi},${jms.browser.queue},${jms.browser.operation}
jxinsight.server.tracer.ext.jms.serversession.trace.identifiers=${jms.serversession.jndi},${jms.serversession.operation}
jxinsight.server.tracer.ext.jms.sessionpool.trace.identifiers=${jms.sessionpool.jndi},${jms.sessionpool.operation}
jxinsight.server.tracer.ext.jms.session.trace.identifiers=${jms.session.jndi},${jms.session.operation}
Variables must be delimited by a comma. The list of possible variables for the JMS trace identifiers are:
ConnectionFactory
${jms.connectionfactory.jndi}
${jms.connectionfactory.codesource}
${jms.connectionfactory.package}
${jms.connectionfactory.classname}
${jms.connectionfactory.fullclassname}
${jms.connectionfactory.operation}
${jms.connectionfactory.method}
${jms.connectionfactory.signature}
${trace.timestamp}
Connection
${jms.connection.jndi}
${jms.connection.codesource}
${jms.connection.package}
${jms.connection.classname}
${jms.connection.fullclassname}
${jms.connection.operation}
${jms.connection.method}
${jms.connection.signature}
${trace.timestamp}
Message Consumer
${jms.consumer.jndi}
${jms.consumer.codesource}
${jms.consumer.package}
${jms.consumer.classname}
${jms.consumer.fullclassname}
${jms.consumer.operation}
${jms.consumer.method}
${jms.consumer.signature}
${trace.timestamp}
${jms.consumer.selector}
${jms.consumer.destination}
Destination
${jms.destination.jndi}
${jms.destination.codesource}
${jms.destination.package}
${jms.destination.classname}
${jms.destination.fullclassname}
${jms.destination.operation}
${jms.destination.method}
${jms.destination.signature}
${trace.timestamp}
Page 21 of 47
${jms.exceptionlistener.codesource}
${jms.exceptionlistener.package}
${jms.exceptionlistener.classname}
${jms.exceptionlistener.fullclassname}
${jms.exceptionlistener.operation}
${jms.exceptionlistener.method}
${jms.exceptionlistener.signature}
${trace.timestamp}
Message
${jms.message.jndi}
${jms.message.codesource}
${jms.message.package}
${jms.message.classname}
${jms.message.fullclassname}
${jms.message.operation}
${jms.message.method}
${jms.message.signature}
${trace.timestamp}
Message Listener
${jms.messagelistener.jndi}
${jms.messagelistener.codesource}
${jms.messagelistener.package}
${jms.messagelistener.classname}
${jms.messagelistener.fullclassname}
${jms.messagelistener.operation}
${jms.messagelistener.method}
${jms.messagelistener.signature}
${jms.messagelistener.destination}
${trace.timestamp}
Message Producer
${jms.producer.jndi}
${jms.producer.codesource}
${jms.producer.package}
${jms.producer.classname}
${jms.producer.fullclassname}
${jms.producer.operation}
${jms.producer.method}
${jms.producer.signature}
${trace.timestamp}
Queue Browser
${jms.browser.jndi}
${jms.browser.queue}
${jms.browser.selector}
${jms.browser.queue}
${jms.browser.operation}
${jms.browser.method}
${jms.browser.signature}
${trace.timestamp}
Server Session
${jms.serversession.jndi}
${jms.serversession.codesource}
${jms.serversession.operation}
${jms.serversession.method}
${jms.serversession.signature}
${trace.timestamp}
Session
${jms.session.jndi}
${jms.session.codesource}
${jms.session.package}
${jms.session.classname}
Page 22 of 47
${jms.session.fullclassname}
${jms.session.operation}
${jms.session.method}
${jms.session.signature}
${trace.timestamp}
To turn on or off the tracing specify the following server system property
jxinsight.server.tracer.ext.jms.message.distributed.trace.enabled=true|false (default is true)
Page 23 of 47
SolarMetric Kodo JDO Trace Extension [jxinsight-ext-kodo.jar]
The trace extension traces and profiles all invocations on instances of the javax.jdo.PersistenceManager, javax.jdo.Query and
javax.jdo.Extent as well a recording notifications of Instance Lifecycle events. The JDO trace extension is highly configurable in terms of
level of tracing, contextual information appended to model, and aggregation of traces.
This extension can be installed by setting the following property in the kodo.properties file:
kodo.PersistenceManagerImpl=com.jinspired.jxinsight.trace.ext.jdo.kodo.PersistenceManager
The JXInsight class extends from the default Kodo persistence manager implementation class which is standard plug-in
capability within the Kodo product.
The trace extension has numerous settings to define the level of tracing
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.delete.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.evict.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.makepersistent.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.maketransactional.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.makenontransactional.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.maketransient.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.newquery.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.refresh.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.retrieve.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.getextent.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.getobjectid.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.attach.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.detach.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.flush.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.trace.consistency.enabled=true
The extension can also proxy objects returned from the persistence manager for greater trace coverage
Page 24 of 47
jxinsight.server.tracer.ext.jdo.kodo.manager.proxy.query.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.proxy.extent.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.manager.proxy.transaction.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.query.trace.close.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.query.trace.execute.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.query.trace.compile.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.query.trace.getters.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.query.trace.setters.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.extent.trace.close.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.extent.trace.iterator.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.extent.trace.list.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.extent.trace.getters.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.extent.trace.setters.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.lifecycle.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.transaction.trace.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.transaction.trace.begin.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.transaction.trace.commit.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.transaction.trace.rollback.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.transaction.trace.getters.enabled=true
jxinsight.server.tracer.ext.jdo.kodo.transaction.trace.setters.enabled=true
The extension can be configured to delimit a trace into distinct trace identifiers using the following system
jxinsight.server.tracer.ext.jdo.kodo.lifecycle.trace.identifiers=${jdo.instance.classname},${jdo.instance.event}
jxinsight.server.tracer.ext.jdo.kodo.transaction.trace.identifiers=${jdo.transaction.operation}
jxinsight.server.tracer.ext.jdo.kodo.extent.trace.identifiers=${jdo.instance.classname},${jdo.extent.operation}
jxinsight.server.tracer.ext.jdo.kodo.query.trace.identifiers=${jdo.instance.classname},${jdo.query.filter},${jdo.query.operation}
Variables must be delimited by a comma. The list of possible variables for Kodo JDO trace identifiers are:
Query
${jdo.instance.fullclassname}
${jdo.instance.classname}
${jdo.instance.package}
${jdo.query.operation}
${jdo.query.filter}
${jdo.query.querystring}
${trace.timestamp}
InstanceLifecycleListener
${jdo.instance.package}
${jdo.instance.classname}
${jdo.instance.fullclassname}
${jdo.instance.event}
${jdo.instance.objectid}
${trace.timestamp}
Extent
${jdo.extent.operation}
${jdo.instance.package}
${jdo.instance.classname}
${jdo.instance.fullclassname}
${trace.timestamp}
Page 25 of 47
Logging Trace Extension [jxinsight-core.jar]
The logging (java.util.logging and log4j) trace extension allows for the inclusion of important log events or records in the profile
snapshot. This is useful when analysing an exported snapshot from a benchmark test run and there needs to be some degree of
confidence in the test run such as that no exceptions perturbed the performance figures.
If the enabled flag is set to true then on start up of the JXInsight Tracer a handler instance will be registered against the
loggers. For java.util.logging traces the possible variables are:
${log.tid}
${log.message}
${log.logger}
${log.level}
${log.sequence}
${log.timestamp}
${trace.timestamp}
jxinsight.server.tracer.ext.log4j.enabled=false
jxinsight.server.tracer.ext.log4j.minlevel=WARNING
jxinsight.server.tracer.ext.log4j.trace.identifiers=${log.logger},${log.message}
jxinsight.server.tracer.ext.log4j.loggers=
If the enabled flag is set to true then on start up of the JXInsight Tracer an appender instance will be registered against the
loggers. For log4j traces the possible variables are:
${log.tid}
${log.message}
${log.logger}
Page 26 of 47
${log.level}
${log.timestamp}
${trace.timestamp}
Page 27 of 47
JDBC Trace Extension [jxinsight-core.jar]
The JDBC trace extension traces and profiles all methods on data sources, connections, statements, and result sets. This is different
from the JXInsight JDBC because in a normal J2EE environment the container provides a proxy layer between the user code and
underlying vendor JDBC driver and data sources. With the JXInsight extension users can profile the containers JDBC layer including
managed and transactional connection pools.
There is a difference in behaviour with *.proxy.enabled and *.trace.enabled system flags set. The proxy flag should be always be set to
true when tracing is required because of factory references in the JDBC API - a Statement has a reference to its Connection (statement
factory), and a ResultSet has a reference to its Statement (result set factory). If a subset of the JDBC API is proxied then it is possible
that non-standard usage of the API might alter the tracing and resource behaviour of the application. For example if statements are
proxied but not result sets and a call is made on a result set instance to obtain its statement, the statement returned will not be the
proxied and traced instance. Normally usage of the JDBC API by application code should preclude this possibility.
To enable or disable the JXInsight trace extension for JDBC specify the following system property (default is false):
-Djxinsight.server.tracer.ext.jdbc.proxy.enabled=true
The trace extension has numerous settings to define the level of tracing
jxinsight.server.tracer.ext.jdbc.trace.enabled=false
jxinsight.server.tracer.ext.jdbc.ds.trace.enabled=true
jxinsight.server.tracer.ext.jdbc.cpds.trace.enabled=true
jxinsight.server.tracer.ext.jdbc.xads.trace.enabled=true
jxinsight.server.tracer.ext.jdbc.xaconnection.trace.enabled=true
jxinsight.server.tracer.ext.jdbc.pooledconnection.trace.enabled=true
jxinsight.server.tracer.ext.jdbc.connection.trace.enabled=true
jxinsight.server.tracer.ext.jdbc.statement.trace.enabled=true
jxinsight.server.tracer.ext.jdbc.resultset.trace.enabled=true
The extension can be configured to delimit a trace into distinct trace identifiers using the following system
jxinsight.server.tracer.ext.jdbc.xads.trace.identifiers=${jdbc.datasource.jndi},${jdbc.datasource.operation}
jxinsight.server.tracer.ext.jdbc.cpds.trace.identifiers=${jdbc.datasource.jndi},${jdbc.datasource.operation}
jxinsight.server.tracer.ext.jdbc.ds.trace.identifiers=${jdbc.datasource.jndi},${jdbc.datasource.operation}
jxinsight.server.tracer.ext.jdbc.xaconnection.trace.identifiers=${jdbc.xaconnection.jndi},${jdbc.xaconnection.operation}
jxinsight.server.tracer.ext.jdbc.pooledconnection.trace.identifiers=${jdbc.pooledconnection.jndi},${jdbc.pooledconnection.opera
tion}
jxinsight.server.tracer.ext.jdbc.connection.trace.identifiers=${jdbc.connection.jndi},${jdbc.connection.operation}
jxinsight.server.tracer.ext.jdbc.statement.trace.identifiers=${jdbc.statement.jndi},${jdbc.statement.operation}
jxinsight.server.tracer.ext.jdbc.resultset.trace.identifiers=${jdbc.resultset.jndi},${jdbc.resultset.operation}
The extension can also be configured to only proxy particular JDBC objects and further refine the selection to those coming for
the java comp environment space (java:comp/env/jdbc)
jxinsight.server.tracer.ext.jdbc.ds.proxy.enabled=true
jxinsight.server.tracer.ext.jdbc.cpds.proxy.enabled=true
jxinsight.server.tracer.ext.jdbc.xads.proxy.enabled=true
jxinsight.server.tracer.ext.jdbc.xaconnection.proxy.enabled=true
jxinsight.server.tracer.ext.jdbc.pooledconnection.proxy.enabled=true
jxinsight.server.tracer.ext.jdbc.connection.proxy.enabled=true
jxinsight.server.tracer.ext.jdbc.statement.proxy.enabled=true
jxinsight.server.tracer.ext.jdbc.resultset.proxy.enabled=true
jxinsight.server.tracer.ext.jdbc.ds.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jdbc.cpds.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jdbc.xads.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jdbc.pooledconnection.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jdbc.connection.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jdbc.statement.proxy.onlyjavacompenv=false
jxinsight.server.tracer.ext.jdbc.resultset.proxy.onlyjavacompenv=false
Page 28 of 47
JAX-RPC (WebService) Trace Extension [jxinsight-ext-j2ee.jar]
The JAX-RPC extension profiles instances of javax.xml.rpc.Service and javax.xml.rpc.Call accessed directly or indirectly via a
JNDI lookup ensuring that only component boundary profiling and tracing is performed. The extension is by default enabled. To
turn on or off the JAX-RPC tracing specify the following server system properties
The trace extension can be configured to delimit a trace into distinct trace identifiers.
jxinsight.server.tracer.ext.jaxrpc.service.trace.identifiers=${jaxrpc.service.jndi},${jaxrpc.service.operation}
jxinsight.server.tracer.ext.jaxrpc.call.trace.identifiers=${jaxrpc.call.jndi},${jaxrpc.call.operation},${jaxrpc.call.name}
Variables must be delimited by a comma. The list of possible variables for EJB3 traces are:
Service
${jaxrpc.service.jndi}
${jaxrpc.service.codesource}
${jaxrpc.service.package}
${jaxrpc.service.classname}
${jaxrpc.service.fullclassname}
${jaxrpc.service.operation}
${jaxrpc.service.method}
${jaxrpc.service.signature}
${jaxrpc.service.name} // service name
Call
${jaxrpc.call.jndi}
${jaxrpc.call.codesource}
${jaxrpc.call.package}
${jaxrpc.call.classname}
${jaxrpc.call.fullclassname}
${jaxrpc.call.operation} // java method name
${jaxrpc.call.method}
${jaxrpc.call.signature}
${jaxrpc.call.name} // operation name
${jaxrpc.call.endpoint} // endpoint address
Note: The java.rmi.Remote objects returned via the (JAX-RPC) Service.getPort can traced and profiled by the RMI trace
extension.
Page 29 of 47
Java RMI Trace Extension [jxinsight-core.jar]
The RMI trace extension profiles instances of java.rmi.Remote accessed directly or indirectly via a JNDI lookup ensuring that
only component boundary profiling and tracing is performed. The extension is by default enabled. To turn on or off the RMI
tracing specify the following server system properties
The trace extension can be configured to delimit a trace into distinct trace identifiers.
jxinsight.server.tracer.ext.rmi.remote.trace.identifiers=${rmi.remote.jndi},${rmi.remote.operation}
Variables must be delimited by a comma. The list of possible variables for RMI traces are:
Remote
${rmi.remote.jndi}
${rmi.remote.classname}
${rmi.remote.operation}
${rmi.remote.method}
${rmi.remote.codesource}
${rmi.remote.package}
${rmi.remote.fullclassname}
Page 30 of 47
JBoss Distributed Trace Extension [jxinsight-ext-jboss.jar]
The JXInsight JBoss distributed trace extension is based on the JBoss pluggable container and client proxy interceptor
framework. The trace extension supports the tracing of all EJB (session, entity, and message driven beans) method invocations
within in the container or remote clients. The extension can trace calls across JVMs.
The trace extension can be configured to delimit a trace into distinct trace identifiers using the following system properties:
jxinsight.server.tracer.ext.jboss.client.ejb.home.trace.identifiers=${ejbhome.jndi},${ejbhome.operation}
jxinsight.server.tracer.ext.jboss.client.ejb.object.trace.identifiers=${ejbobject.jndi},${ejbobject.operation}
jxinsight.server.tracer.ext.jboss.container.ejb.home.trace.identifiers=${ejbhome.jndi},${ejbhome.operation}
jxinsight.server.tracer.ext.jboss.container.ejb.object.trace.identifiers=${ejbobject.jndi},${ejbobject.operation}
Variables must be delimited by a comma. The list of possible variables for JBoss traces are:
${ejbhome.jndi}
${ejbhome.codesource}
${ejbhome.package}
${ejbhome.classname}
${ejbhome.fullclassname}
${ejbhome.operation}
${ejbhome.method}
${ejbhome.signature}
${ejbobject.jndi}
${ejbobject.codesource}
${ejbobject.package}
${ejbobject.classname}
${ejbobject.fullclassname}
${ejbobject.operation}
${ejbobject.method}
${ejbobject.signature}
${trace.timestamp}
Distributed tracing can be enabled or disabled via the following client side only JVM system properties
Page 31 of 47
Apache Ant Trace Extension [jxinsight-ext-ant.jar]
The Apache Ant extension can trace and profile the execution of project, targets, and tasks.
The trace extension can be configured to enable or disable the tracing of particular build events.
jxinsight.server.tracer.ext.ant.target.trace.enabled=true
jxinsight.server.tracer.ext.ant.project.trace.enabled=true
jxinsight.server.tracer.ext.ant.task.trace.enabled=true
jxinsight.server.tracer.ext.ant.message.trace.enabled=false
The trace extension can be configured to delimit a trace into distinct trace identifiers using the following system properties:
jxinsight.server.tracer.ext.ant.project.trace.identifiers=${ant.project.name}
jxinsight.server.tracer.ext.ant.target.trace.identifiers=${ant.target.name}
jxinsight.server.tracer.ext.ant.task.trace.identifiers=${ant.task.name}
jxinsight.server.tracer.ext.ant.message.trace.identifiers=${log.message}
Variables must be delimited by a comma. The list of possible variables for the Apache Ant trace identifiers are:
Project
${ant.project.name}
${ant.project.description}
Target
${ant.target.name}
${ant.target.description}
${ant.target.location}
Task
${ant.task.name}
${ant.task.type}
${ant.task.description}
${ant.task.location}
Common
${log.message}
${trace.timestamp}
Note: The trace extension is integrated with JXInsight’s JUnit integration supporting the tracing of local and remote (forked)
JUnitTasks. The trace extension can be configured to enable or disable the tracing of JUnitTasks
jxinsight.server.tracer.ext.ant.junit.enabled=true|false (default is true)
Page 32 of 47
JUnit Trace Extension [jxinsight-ext-junit.jar]
The JUnit trace extension can trace and profile the execution of JUnit tests, test cases and test suites.
The trace extension can be configured to delimit a trace into distinct trace identifiers.
jxinsight.server.tracer.ext.junit.test.trace.identifiers=${junit.test.package},${junit.test.classname}
jxinsight.server.tracer.ext.junit.trace.testcase.identifiers=${junit.testcase.package},${junit.testcase.classname}
jxinsight.server.tracer.ext.junit.trace.testsuite.identifiers=${junit.testsuite.name}
Variables must be delimited by a comma. The list of possible variables for JUnit traces are:
Test
${junit.test.codesource}
${junit.test.package}
${junit.test.classname}
${junit.test.fullclassname}
Test Case
${junit.testcase.name}
${junit.testcase.codesource}
${junit.testcase.package}
${junit.testcase.classname}
${junit.testcase.fullclassname}
Test Suite
${junit.testsuite.name}
${junit.testsuite.codesource}
${junit.testsuite.package}
${junit.testsuite.classname}
${junit.testcase.fullclassname}
Common
${trace.timestamp}
Page 33 of 47
JDO Trace Extension [jxinsight-ext-jdo.jar]
The JDO trace extension profiles JDO persistent manager factories, connections, queries, extents and transactions accessed
directly or indirectly via a JNDI lookup ensuring that only component boundary profiling and tracing is performed.
The extension is by default enabled. To turn on or off the JDO tracing specify the following server system property
-Djxinsight.server.tracer.ext.jdo.proxy.enabled=(true|false) default true
The trace extension can be configured to delimit a trace into distinct trace identifiers.
jxinsight.server.tracer.ext.jdo.managerfactory.trace.identifiers=${jdo.managerfactory.jndi},${jdo.managerfactory.operation}
jxinsight.server.tracer.ext.jdo.manager.trace.identifiers=${jdo.manager.jndi},${jdo.manager.operation}
jxinsight.server.tracer.ext.jdo.query.trace.identifiers=${jdo.query.jndi},${jdo.query.filter},${jdo.query.operation}
jxinsight.server.tracer.ext.jdo.extent.trace.identifiers=${jdo.extent.jndi},${jdo.extent.operation}
jxinsight.server.tracer.ext.jdo.transaction.trace.identifiers=${jdo.transaction.jndi},${jdo.transaction.operation}
Variables must be delimited by a comma. The list of possible variables for JDO traces is:
PersistenceManagerFactory
${jdo.managerfactory.jndi}
${jdo.managerfactory.codesource}
${jdo.managerfactory.package}
${jdo.managerfactory.classname}
${jdo.managerfactory.fullclassname}
${jdo.managerfactory.operation}
${jdo.managerfactory.method}
${jdo.managerfactory.signature}
PersistenceManager
${jdo.manager.jndi}
${jdo.manager.codesource}
${jdo.manager.package}
${jdo.manager.classname}
${jdo.manager.fullclassname}
${jdo.manager.operation}
${jdo.manager.method}
${jdo.manager.signature}
Extent
${jdo.extent.jndi}
${jdo.extent.candidateclass}
${jdo.extent.codesource}
${jdo.extent.package}
${jdo.extent.classname}
${jdo.extent.fullclassname}
${jdo.extent.operation}
${jdo.extent.method}
${jdo.extent.signature}
Query
${jdo.query.jndi}
${jdo.query.codesource}
${jdo.query.package}
${jdo.query.classname}
${jdo.query.fullclassname}
${jdo.query.operation}
${jdo.query.method}
${jdo.query.signature}
${jdo.query.tostring}
${jdo.query.filter}
Transaction
${jdo.transaction.jndi}
${jdo.transaction.codesource}
${jdo.transaction.package}
${jdo.transaction.classname}
${jdo.transaction.fullclassname}
${jdo.transaction.operation}
${jdo.transaction.method}
${jdo.transaction.signature}
Page 34 of 47
JTS Trace Extension [jxinsight-ext-j2ee.jar]
The JTS trace extension profiles instances of XAResource accessed directly or indirectly via a JNDI lookup ensuring that only
component boundary profiling and tracing is performed.
To turn on the JTS tracing specify the following server system property
-Djxinsight.server.tracer.ext.jts.proxy.enabled=true
The trace extension can be configured to delimit a trace into distinct trace identifiers.
jxinsight.server.tracer.ext.jts.xaresource.trace.identifiers=${jts.xaresource.jndi},${jts.xaresource.operation}
${jts.xaresource.jndi}
${jts.xaresource.classname}
${jts.xaresource.operation}
${jts.xaresource.method}
${jts.xaresource.codesource}
${jts.xaresource.package}
${jts.xaresource.fullclassname}
${trace.timestamp}
Page 35 of 47
JCA CCI Trace Extension [jxinsight-ext-j2ee.jar]
The extension traces and profiles instances of ConnectionFactory, Connection, Interaction, and Record accessed directly or
indirectly via a JNDI lookup ensuring that only component boundary profiling and tracing is performed.
The extension is by default enabled. The trace extension can be configured to delimit a trace into distinct trace identifiers.
jxinsight.server.tracer.ext.jca.cci.connectionfactory.trace.identifiers=${jca.cci.connectionfactory.jndi},${jca.cci.connectionfactory
.operation}
jxinsight.server.tracer.ext.jca.cci.connection.trace.identifiers=${jca.cci.connection.jndi},${jca.cci.connection.operation}
jxinsight.server.tracer.ext.jca.cci.connectionmetadata.trace.identifiers=${jca.cci.connectionmetadata.jndi},${jca.cci.connectionm
etadata.operation}
jxinsight.server.tracer.ext.jca.cci.record.trace.identifiers=${jca.cci.record.jndi},${jca.cci.record.operation}
jxinsight.server.tracer.ext.jca.cci.recordfactory.trace.identifiers=${jca.cci.recordfactory.jndi},${jca.cci.recordfactory.operation}
jxinsight.server.tracer.ext.jca.cci.resultsetinfo.trace.identifiers=${jca.cci.resultsetinfo.jndi},${jca.cci.resultsetinfo.operation}
jxinsight.server.tracer.ext.jca.cci.interaction.trace.identifiers=${jca.cci.interaction.jndi},${jca.cci.interaction.operation}
jxinsight.server.tracer.ext.jca.cci.transaction.trace.identifiers=${jca.cci.transaction.jndi},${jca.cci.transaction.operation}
Variables must be delimited by a comma. The list of possible variables for JCA CCI traces are:
ConnectionFactory
${jca.cci.connectionfactory.jndi}
${jca.cci.connectionfactory.codesource}
${jca.cci.connectionfactory.package}
${jca.cci.connectionfactory.classname}
${jca.cci.connectionfactory.fullclassname}
${jca.cci.connectionfactory.operation}
${jca.cci.connectionfactory.method}
${jca.cci.connectionfactory.signature}
Connection
${jca.cci.connection.jndi}
${jca.cci.connection.codesource}
${jca.cci.connection.package}
${jca.cci.connection.classname}
${jca.cci.connection.fullclassname}
${jca.cci.connection.operation}
${jca.cci.connection.method}
ConnectionMetaData
${jca.cci.connectionmetadata.jndi}
${jca.cci.connectionmetadata.codesource}
${jca.cci.connectionmetadata.package}
${jca.cci.connectionmetadata.classname}
${jca.cci.connectionmetadata.fullclassname}
${jca.cci.connectionmetadata.operation}
${jca.cci.connectionmetadata.method}
Interaction
${jca.cci.interaction.jndi}
${jca.cci.interaction.codesource}
${jca.cci.interaction.package}
${jca.cci.interaction.classname}
${jca.cci.interaction.fullclassname}
${jca.cci.interaction.operation}
${jca.cci.interaction.method}
LocalTransaction
${jca.cci.transaction.jndi}
${jca.cci.transaction.codesource}
${jca.cci.transaction.package}
${jca.cci.transaction.classname}
${jca.cci.transaction.fullclassname}
${jca.cci.transaction.operation}
${jca.cci.transaction.method}
MessageListener
${jca.messagelistener.jndi}
${jca.messagelistener.codesource}
${jca.messagelistener.package}
${jca.messagelistener.classname}
Page 36 of 47
${jca.messagelistener.fullclassname}
${jca.messagelistener.operation}
${jca.messagelistener.method}
${jca.messagelistener.signature}
${jca.messagelistener.destination}
RecordFactory
${jca.cci.recordfactory.jndi}
${jca.cci.recordfactory.codesource}
${jca.cci.recordfactory.package}
${jca.cci.recordfactory.classname}
${jca.cci.recordfactory.fullclassname}
${jca.cci.recordfactory.operation}
${jca.cci.recordfactory.method}
Record
${jca.cci.record.jndi}
${jca.cci.record.codesource}
${jca.cci.record.package}
${jca.cci.record.classname}
${jca.cci.record.fullclassname}
${jca.cci.record.operation}
${jca.cci.record.method}
ResultSetInfo
${jca.cci.resultsetinfo.jndi}
${jca.cci.resultsetinfo.codesource}
${jca.cci.resultsetinfo.package}
${jca.cci.resultsetinfo.classname}
${jca.cci.resultsetinfo.fullclassname}
${jca.cci.resultsetinfo.operation}
${jca.cci.resultsetinfo.method}
Common
${trace.timestamp}
Page 37 of 47
Hibernate 2.0/3.0 Trace Extension [jxinsight-ext-hibernate.jar]
The trace extension profiles instances of session factory, session, query, and transaction accessed directly or indirectly via a
JNDI lookup ensuring that only component boundary profiling and tracing is performed.
The extension is by default enabled. To turn on or off the Hibernate tracing specify the following server system property
-Djxinsight.server.tracer.ext.hibernate.proxy.enabled=(true|false) default true
The trace extension can be configured to delimit a trace into distinct trace identifiers.
jxinsight.server.tracer.ext.hibernate.sessionfactory.trace.identifiers=${hibernate.sessionfactory.jndi},${hibernate.sessionfactory.
operation}
jxinsight.server.tracer.ext.hibernate.session.trace.identifiers=${hibernate.session.jndi},${hibernate.session.operation}
jxinsight.server.tracer.ext.hibernate.query.trace.identifiers=${hibernate.query.jndi},${hibernate.query.querystring},${hibernate.
query.operation}
jxinsight.server.tracer.ext.hibernate.transaction.trace.identifiers=${hibernate.transaction.jndi},${hibernate.transaction.operation
}
Variables must be delimited by a comma. The list of possible variables for Hibernate traces are:
SessionFactory
${hibernate.sessionfactory.jndi}
${hibernate.sessionfactory.codesource}
${hibernate.sessionfactory.package}
${hibernate.sessionfactory.classname}
${hibernate.sessionfactory.fullclassname}
${hibernate.sessionfactory.operation}
${hibernate.sessionfactory.method}
${hibernate.sessionfactory.signature}
Session
${hibernate.session.jndi}
${hibernate.session.codesource}
${hibernate.session.package}
${hibernate.session.classname}
${hibernate.session.fullclassname}
${hibernate.session.operation}
${hibernate.session.method}
${hibernate.session.signature}
Query
${hibernate.query.jndi}
${hibernate.query.codesource}
${hibernate.query.package}
${hibernate.query.classname}
${hibernate.query.fullclassname}
${hibernate.query.operation}
${hibernate.query.method}
${hibernate.query.signature}
${hibernate.query.tostring}
${hibernate.query.filter}
Transaction
${hibernate.transaction.jndi}
${hibernate.transaction.codesource}
${hibernate.transaction.package}
${hibernate.transaction.classname}
${hibernate.transaction.fullclassname}
${hibernate.transaction.operation}
${hibernate.transaction.method}
${hibernate.transaction.signature}
Common
${trace.timestamp}
Page 38 of 47
Java Content Repository (JCR) Trace Extension [jxinsight-ext-jcr.jar]
The extension profiles instances of repository, workspace, session, node, property, version, version history, query, query
manager, lock and node type accessed directly or indirectly via a JNDI lookup ensuring that only component boundary profiling
and tracing is performed. The extension is by default enabled.
To turn on or off the JCR tracing specify the following server system property
-Djxinsight.server.tracer.ext.jcr.proxy.enabled=(true|false) default true
jxinsight.server.tracer.ext.jcr.repository.proxy.enabled=true
jxinsight.server.tracer.ext.jcr.workspace.proxy.enabled=true
jxinsight.server.tracer.ext.jcr.session.proxy.enabled=true
jxinsight.server.tracer.ext.jcr.node.proxy.enabled=true
jxinsight.server.tracer.ext.jcr.nodetype.proxy.enabled=true
jxinsight.server.tracer.ext.jcr.nodeiterator.proxy.enabled=true
jxinsight.server.tracer.ext.jcr.property.proxy.enabled=true
jxinsight.server.tracer.ext.jcr.propertyiterator.proxy.enabled=true
jxinsight.server.tracer.ext.jcr.querymanager.proxy.enabled=true
jxinsight.server.tracer.ext.jcr.query.proxy.enabled=true
jxinsight.server.tracer.ext.jcr.version.proxy.enabled=true
jxinsight.server.tracer.ext.jcr.versionhistory.proxy.enabled=true
jxinsight.server.tracer.ext.jcr.lock.proxy.enabled=true
The trace extension can be configured to delimit a trace into distinct trace identifiers.
jxinsight.server.tracer.ext.jcr.repository.trace.identifiers=${jcr.repository.jndi},${jcr.repository.operation}
jxinsight.server.tracer.ext.jcr.workspace.trace.identifiers=${jcr.workspace.jndi},${jcr.workspace.name},${jcr.workspace.operati
on}
jxinsight.server.tracer.ext.jcr.session.trace.identifiers=${jcr.session.jndi},${jcr.session.operation}
jxinsight.server.tracer.ext.jcr.node.trace.identifiers=${jcr.node.jndi},${jcr.node.nodetype},${jcr.node.operation}
jxinsight.server.tracer.ext.jcr.nodeiterator.trace.identifiers=${jcr.nodeiterator.jndi},${jcr.nodeiterator.operation}
jxinsight.server.tracer.ext.jcr.nodetype.trace.identifiers=${jcr.nodetype.jndi},${jcr.nodetype.name},${jcr.nodetype.operation}
jxinsight.server.tracer.ext.jcr.property.trace.identifiers=${jcr.property.jndi},${jcr.property.name},${jcr.property.operation}
jxinsight.server.tracer.ext.jcr.propertyiterator.trace.identifiers=${jcr.propertyiterator.jndi},${jcr.propertyiterator.operation}
jxinsight.server.tracer.ext.jcr.querymanager.trace.identifiers=${jcr.querymanager.jndi},${jcr.querymanager.operation}
jxinsight.server.tracer.ext.jcr.query.trace.identifiers=${jcr.query.jndi},${jcr.query.operation}
jxinsight.server.tracer.ext.jcr.version.trace.identifiers=${jcr.version.jndi},${jcr.version.nodetype},${jcr.version.operation}
jxinsight.server.tracer.ext.jcr.versionhistory.trace.identifiers=${jcr.versionhistory.jndi},${jcr.versionhistory.nodetype},${jcr.versi
onhistory.operation}
jxinsight.server.tracer.ext.jcr.lock.trace.identifiers=${jcr.lock.jndi},${jcr.lock.nodetype},${jcr.lock.operation}
Variables must be delimited by a comma. The list of possible variables for JCR traces are:
Repository
${jcr.repository.jndi}
${jcr.repository.classname}
${jcr.repository.operation}
${jcr.repository.method}
${jcr.repository.codesource}
${jcr.repository.package}
${jcr.repository.fullclassname}
Workspace
${jcr.workspace.jndi}
${jcr.workspace.classname}
${jcr.workspace.operation}
${jcr.workspace.method}
${jcr.workspace.codesource}
${jcr.workspace.package}
${jcr.workspace.fullclassname}
${jcr.workspace.name}
Session
${jcr.session.jndi}
${jcr.session.classname}
${jcr.session.operation}
${jcr.session.method}
${jcr.session.codesource}
${jcr.session.package}
Page 39 of 47
${jcr.session.fullclassname}
${jcr.session.userid}
Node
${jcr.node.jndi}
${jcr.node.classname}
${jcr.node.operation}
${jcr.node.method}
${jcr.node.codesource}
${jcr.node.package}
${jcr.node.fullclassname}
${jcr.node.name}
${jcr.node.nodetype}
NodeType
${jcr.nodetype.jndi}
${jcr.nodetype.classname}
${jcr.nodetype.operation}
${jcr.nodetype.method}
${jcr.nodetype.codesource}
${jcr.nodetype.package}
${jcr.nodetype.fullclassname}
${jcr.nodetype.name}
NodeIterator
${jcr.nodeiterator.jndi}
${jcr.nodeiterator.classname}
${jcr.nodeiterator.operation}
${jcr.nodeiterator.method}
${jcr.nodeiterator.codesource}
${jcr.nodeiterator.package}
${jcr.nodeiterator.fullclassname}
Property
${jcr.property.jndi}
${jcr.property.classname}
${jcr.property.operation}
${jcr.property.method}
${jcr.property.codesource}
${jcr.property.package}
${jcr.property.fullclassname}
${jcr.property.name}
PropertyIterator
${jcr.propertyiterator.jndi}
${jcr.propertyiterator.classname}
${jcr.propertyiterator.operation}
${jcr.propertyiterator.method}
${jcr.propertyiterator.codesource}
${jcr.propertyiterator.package}
${jcr.propertyiterator.fullclassname}
Version
${jcr.version.jndi}
${jcr.version.classname}
${jcr.version.operation}
${jcr.version.method}
${jcr.version.codesource}
${jcr.version.package}
${jcr.version.fullclassname}
${jcr.version.name}
${jcr.version.nodetype}
VersionHistory
${jcr.versionhistory.jndi}
${jcr.versionhistory.classname}
${jcr.versionhistory.operation}
${jcr.versionhistory.method}
${jcr.versionhistory.codesource}
${jcr.versionhistory.package}
Page 40 of 47
${jcr.versionhistory.fullclassname}
${jcr.versionhistory.name}
${jcr.versionhistory.nodetype}
Query
${jcr.query.jndi}
${jcr.query.classname}
${jcr.query.operation}
${jcr.query.method}
${jcr.query.codesource}
${jcr.query.package}
${jcr.query.fullclassname}
${jcr.query.statement}
QueryManager
${jcr.querymanager.jndi}
${jcr.querymanager.classname}
${jcr.querymanager.operation}
${jcr.querymanager.method}
${jcr.querymanager.codesource}
${jcr.querymanager.package}
${jcr.querymanager.fullclassname}
Lock
${jcr.lock.jndi}
${jcr.lock.classname}
${jcr.lock.operation}
${jcr.lock.method}
${jcr.lock.codesource}
${jcr.lock.package}
${jcr.lock.fullclassname}
${jcr.lock.token}
${jcr.lock.owner}
${jcr.lock.nodename}
${jcr.lock.nodetype}
Page 41 of 47
EJB 3 Trace Extension [jxinsight-ext-ejb3.jar]
The trace extension profiles instances of entity manager and query accessed directly or indirectly via a JNDI lookup ensuring
that only component boundary profiling and tracing is performed. The extension is by default enabled.
To turn on or off the EJB3 tracing specify the following server system properties
jxinsight.server.tracer.ext.ejb.query.proxy.enabled=true|false (default is true)
jxinsight.server.tracer.ext.ejb.entitymanager.proxy.enabled=true|false (default is true)
The trace extension can be configured to delimit a trace into distinct trace identifiers.
jxinsight.server.tracer.ext.ejb.entitymanager.trace.identifiers=${ejb.entitymanager.jndi},${ejb.entitymanager.operation}
jxinsight.server.tracer.ext.ejb.query.trace.identifiers=${ejb.query.jndi},${ejb.query.querystring},${ejb.query.operation}
Variables must be delimited by a comma. The list of possible variables for EJB3 traces are:
EntityManager
${ejb.entitymanager.jndi}
${ejb.entitymanager.codesource}
${ejb.entitymanager.package}
${ejb.entitymanager.classname}
${ejb.entitymanager.fullclassname}
${ejb.entitymanager.operation}
${ejb.entitymanager.method}
${ejb.entitymanager.signature}
Query
${ejb.query.jndi}
${ejb.query.codesource}
${ejb.query.package}
${ejb.query.classname}
${ejb.query.fullclassname}
${ejb.query.operation}
${ejb.query.method}
${ejb.query.signature}
${ejb.query.querystring}
EntityTransaction
${ejb.entitytransaction.jndi}
${ejb.entitytransaction.codesource}
${ejb.entitytransaction.package}
${ejb.entitytransaction.classname}
${ejb.entitymanager.fullclassname}
${ejb.entitytransaction.operation}
${ejb.entitytransaction.method}
${ejb.entitytransaction.signature}
Common
${trace.timestamp}
Page 42 of 47
Spring Trace Extension [jxinsight-ext-spring.jar]
One of the key components of the Spring framework is its AOP framework which allows users to implement custom aspects,
complementing their use of OOP with AOP. JXInsight trace extension provides a plug-in replacement for the basic performance
and debugging interceptors distributed with the Spring libraries. The JXInsight TraceInterceptor provides high resolution clock
counters, JVM statistics including GC time, CPU time, object allocations, thread blocking and waiting per trace interval as well as
call stack inspection and classification and integration into the award winning JXInsight console.
The class com.jinspired.jxinsight.trace.ext.spring.TraceInterceptor implements PointCutAdvisor and Advice allowing for easy
introduction into an Spring application. The TraceInterceptor can be used in conjunction with existing Spring Advisors such as
org.springframework.aop.support.RegexpMethodPointcutAdvisor for fine grain control of tracing.
For ease of use the TraceInterceptor can act as both Advisor and Advice with global application
to all proxy factory beans with a reference.
Page 43 of 47
WorkManager/TimerManager Trace Extension [jxinsight-ext-commonj.jar]
The trace extension profiles instances of WorkManager, Work, WorkItem, WorkListener, WorkEvent, TimerManager, Timer, and
TimerListener.
The extension is by default enabled. To turn on or off the tracing specify the following server system properties
jxinsight.server.tracer.ext.commonj.workmanager.proxy.enabled=true
jxinsight.server.tracer.ext.commonj.work.proxy.enabled=true
jxinsight.server.tracer.ext.commonj.workitem.proxy.enabled=true
jxinsight.server.tracer.ext.commonj.worklistener.proxy.enabled=true
jxinsight.server.tracer.ext.commonj.workevent.proxy.enabled=true
jxinsight.server.tracer.ext.commonj.timermanager.proxy.enabled=true
jxinsight.server.tracer.ext.commonj.timer.proxy.enabled=true
jxinsight.server.tracer.ext.commonj.timerlistener.proxy.enabled=true
The trace extension can be configured to delimit a trace into distinct trace identifiers.
jdbinsight.server.tracer.ext.commonj.workmanager.trace.identifiers=
${commonj.workmanager.jndi},${commonj.workmanager.classname},${commonj.workmanager.operation}
jdbinsight.server.tracer.ext.commonj.work.trace.identifiers=
${commonj.work.jndi},${commonj.work.classname},${commonj.work.operation}
jdbinsight.server.tracer.ext.commonj.workitem.trace.identifiers=
${commonj.workitem.jndi},${commonj.workitem.classname},${commonj.workitem.operation}
jdbinsight.server.tracer.ext.commonj.worklistener.trace.identifiers=
${commonj.worklistener.jndi},${commonj.worklistener.classname},${commonj.worklistener.operation}
jdbinsight.server.tracer.ext.commonj.workevent.trace.identifiers=
${commonj.workevent.jndi},${commonj.workevent.classname},${commonj.workevent.operation}
jdbinsight.server.tracer.ext.commonj.timermanager.trace.identifiers=
${commonj.timermanager.jndi},${commonj.timermanager.classname},${commonj.timermanager.operation}
jdbinsight.server.tracer.ext.commonj.timer.trace.identifiers=
${commonj.timer.jndi},${commonj.timer.classname},${commonj.timer.operation}
jdbinsight.server.tracer.ext.commonj.timerlistener.trace.identifiers=
${commonj.timerlistener.jndi},${commonj.timerlistener.classname},${commonj.timerlistener.operation}
Variables must be delimited by a comma. The list of possible variables for traces is:
WorkManager
${commonj.workmanager.jndi}
${commonj.workmanager.classname}
${commonj.workmanager.operation}
${commonj.workmanager.method}
${commonj.workmanager.codesource}
${commonj.workmanager.package}
${commonj.workmanager.fullclassname}
Work
${commonj.work.jndi}
${commonj.work.classname}
${commonj.work.operation}
${commonj.work.method}
${commonj.work.codesource}
${commonj.work.package}
${commonj.work.fullclassname}
WorkItem
${commonj.workitem.jndi}
${commonj.workitem.classname}
${commonj.workitem.operation}
${commonj.workitem.method}
${commonj.workitem.codesource}
${commonj.workitem.package}
${commonj.workitem.fullclassname}
WorkEvent
${commonj.workevent.jndi}
${commonj.workevent.classname}
${commonj.workevent.operation}
${commonj.workevent.method}
Page 44 of 47
${commonj.workevent.codesource}
${commonj.workevent.package}
${commonj.workevent.fullclassname}
WorkListener
${commonj.worklistener.jndi}
${commonj.worklistener.classname}
${commonj.worklistener.operation}
${commonj.worklistener.method}
${commonj.worklistener.codesource}
${commonj.worklistener.package}
${commonj.worklistener.fullclassname}
TimerManager
${commonj.timermanager.jndi}
${commonj.timermanager.classname}
${commonj.timermanager.operation}
${commonj.timermanager.method}
${commonj.timermanager.codesource}
${commonj.timermanager.package}
${commonj.timermanager.fullclassname}
Timer
${commonj.timer.jndi}
${commonj.timer.classname}
${commonj.timer.operation}
${commonj.timer.method}
${commonj.timer.codesource}
${commonj.timer.package}
${commonj.timer.fullclassname}
TimerListener
${commonj.timerlistener.jndi}
${commonj.timerlistener.classname}
${commonj.timerlistener.operation}
${commonj.timerlistener.method}
${commonj.timerlistener.codesource}
${commonj.timerlistener.package}
${commonj.timerlistener.fullclassname}
Page 45 of 47
Chapter 5 – Server Installation and Configurations
1. Place the jxinsight-core.jar library and optionally the jxinsight-jdbc-drivers.jar library on the classpath of the application
server, web container, or client JVM process. Add the required jxinsight-ext-*.jar libraries to either previous mentioned
classpath or a J2EE application or Web archive (maybe an expanded directory).
2. Install the native library jdbinsight on the library path of the server. The native library for different platforms can be found
in the bin directory.
4. Depending on the application and datasource configuration (JDBC 1.x based) there might be a need to specify the
underlying JDBC driver that JDBInsight will proxy
-Djdbc.drivers=com.somejdbcvendor.Driver,com.anotherjdbcvendor.Driver
Environment variables are operating-system dependent, on Linux and Solaris the environment variable LD_LIBRARY_PATH is a
colon separated list of directories that extends the java.library.path. The command setenv LD_LIBRARY_PATH
/<JXINSIGHT_LIB_DIR> ensures the directory is added to the search path. For further information on the LD_LIBRARY_PATH
variable please refer to the man page for the ld command, or in a command referred to by that man page.
On some UNIX flavours you are required to give the library execute privileges as well as placing the lib in Java JRE lib directory.
For example on HP-UX (PA-RISC) the libjdbinsight.sl should be copied into /opt/java.x.x/jre/lib/PA_RISC2.0/ and then executing
chmod 777 libjdbinsight.sl
It should also be possible to path to the library as long as no driver letter is used. For example the following will load the library
from sub directory lib/windows to the current one.
java -Xrun"lib/windows/jdbinsight"
JXInsight Server
Page 46 of 47
When the either the JDBInsight JDBC Driver or JXInsight Tracer are first instantiated in a process, they will initialize the server
component. The server component loads and starts the profiler, as well as starting the reactor and transmitter components.
The reactor component allows consoles to connect into the process and retrieve the profiling information. The transmitter
component broadcasts the reactor’s socket binding information on the local subnet. The broadcasting of the binding enables
consoles to automatically detect available servers on the local subnet. The reactor component first attempts to create a server
socket binding based on the system port specified. In the event that this port is in use (another JXInsight server process started
on the same machine), the reactor will continue incrementing the port number until a free port is found.
// <jxinsight-install-root>filters/atlassian.jira.tomcat.filters.config
!sun.reflect
!java.lang.reflect
!java.awt
!$Proxy
!org.omg.CORBA.portable.ObjectImpl
!org.apache.coyote
!org.apache.catalina
!org.apache.jasper
!org.apache.tomcat.util
!weblogic
!COM.jrockit
!com.atlassian
com.atlassian.jira.web.action
!org.apache.jasper.servlet.JspServletWrapper
!webwork
!org.apache.velocity
!com.opensymphony
!org.ofbiz.core.entity
!org.apache.commons
!org.picocontainer
Page 47 of 47