API do agente Java para aplicativo assíncrono

Considere o método parallelStream() no trecho de código abaixo. Como algumas das chamadas para requestItemAsync() ocorrerão em um encadeamento separado, um token é criado e transmitido para vincular esse trabalho assíncrono de volta ao encadeamento 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);
}

As chamadas de API do agente neste exemplo são:

• @Trace(dispatcher = true): diz ao agente para iniciar uma transação. Para obter mais informações sobre esse método, consulte o Javadoc.
• getToken(): Cria o token que vinculará o trabalho. Para obter mais informações sobre esse método, consulte o Javadoc.
• token.expire(): Expira o token. Isso permite que a transação termine. Para obter mais informações sobre esse método, consulte o Javadoc.

O exemplo de código a seguir mostra requestItemAsync, que pode ser executado em um thread separado do thread solicitante. Por esse motivo, o token que foi criado no exemplo de código anterior está vinculado à transação em requestItemAsync. Observe que requestItemAsync() possui a anotação @Trace(async=true), que informa ao agente para trace esse método se ele estiver vinculado a uma transação existente.

Depois que parallelStream() coletar todos os resultados, o token expirará. Isso é importante porque garante que a transação não permaneça aberta após a conclusão de parallelStream() .

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

As chamadas de API do agente neste exemplo são:

• @Trace(async = true): inicia uma transação. Para obter mais informações sobre esse método, consulte o Javadoc.
• token.link(): Vincula o trabalho que está sendo realizado em requestItemAsync() (que está sendo executado em um thread diferente) ao thread solicitante. Para obter mais informações sobre esse método, consulte o Javadoc.

Para visualizar detalhes do rastreamento da transação, acesse: one.newrelic.com APM & services > (select an app) > Transactions > Transaction trace > Trace details.

A atividade assíncrono é mostrada na visualização em cascata trace por segmentos que se sobrepõem horizontalmente, na dimensão de tempo.

Não é necessário vincular métodos que estejam no mesmo thread, mas isso não terá efeito negativo. Muitas vezes acontece que um único token pode ser compartilhado, como no exemplo parallelStream() .

O método abaixo faz uma chamada para um serviço externo (neste caso um banco de dados) usando o 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);
    }
}

O objetivo, neste caso, é descobrir quanto tempo o Callable na instrução Lambda está aguardando no pool de threads antes de ser executado, em vez de determinar quanto tempo storeItem() é executado. Por esse motivo, um segmento é usado em vez de um token e @Trace(async = true) não é necessário como era para um token.

A chamada da API do agente neste exemplo é:

• @Trace(dispatcher = true): inicia uma transação. Para obter mais informações sobre esse método, consulte o Javadoc.

O exemplo de código a seguir mostra um segmento começando no método storeItem para medir quanto tempo a instrução Lambda está aguardando no pool de threads. Para parar de cronometrar o segmento, você deve chamar .end() ou .ignore(). Se você don't desejar relatar o segmento como parte de sua transação pai, chame .ignore(). Caso contrário, para relatar o segmento como parte de sua transação pai, chame .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);
    });
}

As chamadas de API do agente neste exemplo são:

• startSegment(...): inicia o segmento que cronometrará o código. Para obter mais informações sobre esse método, consulte o Javadoc.
• reportAsExternal(DatastoreParameters()): Associa a hora a uma chamada externa do armazenamento de dados. Isso aparecerá no APM com dados do armazenamento de dados. Para obter mais informações, consulte API reportAsExternal.
• segment.end(): Interrompe a cronometragem deste segmento. Para obter mais informações sobre esse método, consulte o Javadoc.

Quando o método é concluído, o APM exibe um trace da transação com uma chamada externa.