Extensión de Request Metrics
Algunas aplicaciones pueden exigir puntos de instrumentación adicionales dentro del flujo de Request Metrics. Por ejemplo, puede que desee comprender el tiempo de respuesta a un sistema de fondo exclusivo como se muestra en el gráfico de llamada siguiente.
HTTP request /trade/scenario ------------------------------> 172 ms
Servlet/trade/scenario --------------------------------> 130 ms
Servlet/call to unique back-end system -------------------------->38 ms
Request Metrics utiliza una "señal" o "correlacionador" al rastrear el flujo de cada petición a través del sistema. Para crear el gráfico de llamada anterior con esta instrumentación, debe conectarse a ese flujo de la petición y emitir la API de ARM (Application Response Measurement) adecuada para que un agente de ARM recopile los datos y el proveedor de ARM cree el gráfico de llamada.
- Cree un nuevo objeto ArmTransaction, que ejecuta diversas llamadas de instrumentación como un inicio o una detención. La envoltura de ARM del servicio de correlación (PmiRmArmTx) encapsula este objeto antes de que se inserte en el flujo de Request Metrics.
- Llene el objeto ArmTransaction con el objeto ArmCorrelator adecuado. Este objeto encapsula los bytes del correlacionador de ARM.
- Ejecute el método start en el objeto ArmTransaction marcando el principio del método instrumentado.
- Cree una instancia del objeto PmiRmArmTx con el método estático en la clase PmiRmArmTxFactory y llene el objeto PmiRmArmTx con el objeto anteriorArmTransaction.
- Pase el objeto PmiRmArmTx anterior al servicio de correlación colocándolo en la pila del servicio de correlación mediante métodos expuestos en la clase PmiRmArmStack.
- Lleve a cabo las tareas que tenga que realizar el método que se va a instrumentar. El servicio de correlación se encarga del flujo del objeto ArmTransaction según sea necesario, lo que puede dar como resultado la vías de gráfico de llamada de tiempos de transacción.
- Al final del método instrumentado, acceda al objeto PmiRmArmTx desde el servicio de correlación mediante los métodos expuestos en la clase PmiRmArmStack, acceda al objeto ArmTransaction y realice una detención para indicar el final de la transacción.
Consulte esta información cuando utilice la API de ARM con el servicio de correlaciones como parte de la instrumentación de un servlet.
Los binarios arm40 deben instalarse de acuerdo a las instrucciones de instalación suministradas por el proveedor de la implementación. Una vez hecho esto, reinicie el servidor. Esto producirá que se generen registros de rastreo en el archivo SystemOut.log que indican la creación de instancias de la implementación de ARM adecuada. En el ejemplo siguiente se ilustra uno de los flujos de trabajo habituales del uso de la API ARM junto con el servicio de correlación como parte de una instrumentación del servlet:
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
PmiRmArmTx artrax =
// La fábrica detecta la implementación de ARM activa (que especifica el usuario a través de
// la consola administrativa) e instancia un objeto de envoltorio ARM
PmiRmArmTxFactory.createPmiRmArmTx();
ArmTransaction at = newArmTx();
if (null == at)
out.println("Got a null ArmTransaction");
ArmCorrelator arc = newArmCorr();
at.start(arc);
try {
artrax.setArmTransaction(at);
PmiRmArmStack.pushTransaction(artrax);
} catch (Exception e) {
System.out.println("Caught 1 exception" + e);
}
PmiRmArmTx atxwrp = PmiRmArmStack.peekTransaction();
if (atxwrp == null)
out.println("Armtransaction is null");
//getArmType
try {
out.println("ARMTYPE is"+ PmiRmArmTx.getARMType());
} catch (Exception e) {
out.println(e);
}
//obtención de bytes del correlacionador
try {
if (null == atxwrp.getCorrelatorBytes())
out.println("Got a null Correlator");
} catch (Exception e) {
out.println(e);
}
//bloqueado/desbloqueado
long blkid = 0;
try {
out.println(blkid = atxwrp.blocked());
} catch (Exception e) {
out.println(e);
}
try {
out.println(atxwrp.unblocked(blkid));
} catch (Exception e) {
out.println(e);
}
try {
atxwrp = PmiRmArmStack.popTransaction();
ArmTransaction art = (ArmTransaction) atxwrp.getArmTransaction();
art.stop(ArmConstants.STATUS_GOOD);
} catch (Exception e) {
out.println(e);
}
}
private ArmTransaction newArmTx() {
ArmTransactionFactory txFactory = null;
try {
String sWasName = "WebSphere";
String appName = "t23xpimage/t23xpimage/server1";
String sCellName = appName.substring(0, appName.indexOf("/"));
String sNodeInstance =
appName.substring(appName.indexOf("/") + 1, appName.length());
sNodeInstance = sNodeInstance.replace('/', '.');
txFactory = (ArmTransactionFactory)
newObjectInstance("org.opengroup.arm40.sdk.ArmTransactionFactoryImpl");
ArmApplication app = null; // 149297
ArmApplicationDefinition appDef = null; //LIDB3207
appDef = txFactory.newArmApplicationDefinition(sWasName, null, null);
app = txFactory.newArmApplication(appDef, sCellName, sNodeInstance, null);
String[] idnames = { "request_type" };
String[] idvalues = { "URI" };
String[] ctxnames = { "URI" };
ArmIdentityPropertiesTransaction props =
txFactory.newArmIdentityPropertiesTransaction(
idnames,
idvalues,
ctxnames,
null);
ArmTransactionDefinition atd =
txFactory.newArmTransactionDefinition(
appDef,
"URI",
props,
(ArmID) null);
ArmTransaction at = txFactory.newArmTransaction(app, atd ); return at;
} catch (Exception e) {
System.out.println(e);
return null;
}
}
private ArmCorrelator newArmCorr() {
ArmTransactionFactory txFactory = null;
try {
String sWasName = "WebSphere";
String appName = "t23xpimage/t23xpimage/server1";
txFactory =
(ArmTransactionFactory) newObjectInstance("org.opengroup.arm40.sdk.ArmTransactionFactoryImpl");
ArmCorrelator arc =txFactory.newArmCorrelator(
PmiRmArmStack.peekTransaction().getCorrelatorBytes());
return arc;
} catch (Exception e) {
System.out.println(e);
return null;
}
}
Son varios los casos en los que se puede utilizar PmiRmArmStack. En este ejemplo se muestra un caso en el que el código accede a un PmiRmArmTx existente en la pila, extrae el correlacionador y llama al bloqueo y el desbloqueo. Este es un caso típico en el que el se envía un correlacionador junto con un protocolo no soportado. En este ejemplo, la transacción Arm ya está en la pila.
1 PmiRmArmTx artrax =
2 PmiRmArmStack.peekTransaction();
3 if( artrax != null )
4 {
5 try
6 {
7 byte[] cbytes = artrax.getCorrelatorBytes();
8 stuffBytesIntoOutboundMessage( msg, cbytes);
9 long blockedId = 0;
10 try
11 {
12 blockedId = artrax.blocked();
13 }
14 catch( NoSuchMethodException nsme )
15 {
16 // no debe estar ejecutando ARM4 o eWLM
17 }
18 sendMsg( msg );
19 try
20 {
21 artrax.blocked( blockedId );
22 }
23 catch( NoSuchMethodException nsme )
24 {
25 // no debe estar ejecutando ARM4 o
eWLM
26 }
27
28 }
29 catch( Exception e )
30 {
31 report a problem;
32 }
33 }