Agente de Java API para aplicación asincrónica

Considere el método parallelStream() en el fragmento de código siguiente. Debido a que algunas de las llamadas a requestItemAsync() se producirán en un hilo separado, se crea un token y se pasa para vincular ese trabajo asincrónico al hilo solicitante.

/**
* Example showing multi-threaded implementation of requesting data using a parallel {@link Stream}.
*/
@RequestMapping("parallel_stream")
@Trace(dispatcher = true) // starts a transaction
public ResponseEntity<String> parallelStream(@RequestParam("ids") List<Long> ids) {
    final Token token = NewRelic.getAgent().getTransaction().getToken();
    List<item> results = ids
            .parallelStream()
            .map(id -> requestItemAsync(id, token)) // requestItemAsync represents an  example of work being passed to another thread. The token is passed along to allow linking the work on the new thread back to the thread that the token was originally created on.
            .filter(item -> item != null)
            .collect(Collectors.toList());
    token.expire();
    return formattedResponse("parallel_stream", results);
}

Las llamadas a la API del agente en este ejemplo son:

• @Trace(dispatcher = true): Le dice al agente que inicie una transacción. Para obtener más información sobre este método, consulte el Javadoc.
• getToken(): Crea el token que vinculará el trabajo. Para obtener más información sobre este método, consulte el Javadoc.
• token.expire(): El token caduca. Esto permite que la transacción finalice. Para obtener más información sobre este método, consulte el Javadoc.

El siguiente ejemplo de código muestra requestItemAsync, que podría ejecutarse en un subproceso independiente del subproceso solicitante. Por este motivo, el token que se creó en el ejemplo de código anterior está vinculado a la transacción en requestItemAsync. Tenga en cuenta que requestItemAsync() tiene la anotación @Trace(async=true) , que le indica al agente que trace este método si está vinculado a una transacción existente.

Después de que parallelStream() recopile todos los resultados, el token caduca. Esto es importante porque garantiza que la transacción no permanezca abierta después de que se complete parallelStream() .

@Trace(async = true)
private Item requestItemAsync(long id, Token token) {
    token.link();
    return requestItem(id);
}

Las llamadas a la API del agente en este ejemplo son:

• @Trace(async = true): inicia una transacción. Para obtener más información sobre este método, consulte el Javadoc.
• token.link(): Vincula el trabajo que se está realizando en requestItemAsync() (que se ejecuta en un hilo diferente) al hilo solicitante. Para obtener más información sobre este método, consulte el Javadoc.

Para ver los detalles de la traza de la transacción, vaya a: one.newrelic.com APM & services > (select an app) > Transactions > Transaction trace > Trace details.

La actividad asincrónica se muestra en la vista de cascada de traza mediante segmentos que se superponen horizontalmente, en la dimensión temporal.

No es necesario vincular métodos que están en el mismo hilo, pero hacerlo no tendrá ningún efecto negativo. A menudo ocurre que se puede compartir un único token, como en el ejemplo parallelStream() .

El siguiente método realiza una llamada a un servicio externo (en este caso una base de datos) utilizando el método storeItem():

/**
* Example showing single threaded implementation of inserting data into a datasource.
*/
@RequestMapping("insert")
@Trace(dispatcher = true) //starts a transaction
public ResponseEntity insert(@RequestParam("id") Long id) {
    if (id != null) {
        storeItem(id);
        return new ResponseEntity<>("insert", HttpStatus.OK);
    } else {
        return new ResponseEntity<>("insert", HttpStatus.BAD_REQUEST);
    }
}

El objetivo en este caso es averiguar cuánto tiempo espera Callable en la declaración Lambda en el grupo de subprocesos antes de ejecutarse, en lugar de determinar cuánto tiempo se ejecuta storeItem() . Por este motivo, se utiliza un segmento en lugar de un token y @Trace(async = true) no es necesario como lo era para un token.

La llamada API del agente en este ejemplo es:

• @Trace(dispatcher = true): inicia una transacción. Para obtener más información sobre este método, consulte el Javadoc.

El siguiente ejemplo de código muestra un segmento que comienza en el método storeItem para medir cuánto tiempo espera la declaración Lambda en el grupo de subprocesos. Para dejar de cronometrar el segmento, debe llamar a .end() o .ignore(). Si don't desea informar el segmento como parte de su transacción principal, llame a .ignore(). De lo contrario, para informar el segmento como parte de su transacción principal, llame a .end().

private void storeItem(long id) {
    Segment segment = NewRelic.getAgent().getTransaction().startSegment("storeItem");

    segment.reportAsExternal(DatastoreParameters
           .product("H2")
           .collection(null)
           .operation("insert")
           .instance("localhost", 8080)
           .databaseName("test")
           .build());

    // fire and forget
    DB_POOL.submit(() -> {
        segment.end();
        insertData(id);
    });
}

Las llamadas a la API del agente en este ejemplo son:

• startSegment(...): Comienza el segmento que cronometrará el código. Para obtener más información sobre este método, consulte el Javadoc.
• reportAsExternal(DatastoreParameters()): Asocia la hora con una llamada externa de almacenamiento de datos. Esto se mostrará en APM con almacenamiento de datos datos. Para obtener más información, consulte API reportAsExternal.
• segment.end(): Detiene el cronometraje de este segmento. Para obtener más información sobre este método, consulte el Javadoc.

Cuando se completa el método, APM muestra una traza de la transacción con una llamada externa.