agent Java API pour les applications asynchrones

Considérez la méthode parallelStream() dans le snippet de code ci-dessous. Étant donné que certains des appels à requestItemAsync() se produiront sur un thread distinct, un jeton est créé et transmis pour relier ce travail asynchrone au thread demandeur.

/**
* 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);
}

Les API d'appelsagent dans cet exemple sont :

• @Trace(dispatcher = true): Indique à l'agent de démarrer une transaction. Pour en savoir plus sur cette méthode, consultez la Javadoc.
• getToken(): Crée le jeton qui reliera les œuvres entre elles. Pour en savoir plus sur cette méthode, consultez la Javadoc.
• token.expire(): Le jeton expire. Cela permet à la transaction de se terminer. Pour en savoir plus sur cette méthode, consultez la Javadoc.

L'exemple de code suivant montre requestItemAsync, qui peut s'exécuter sur un thread distinct du thread demandeur. Pour cette raison, le jeton qui a été créé dans l'exemple de code précédent est lié à la transaction dans requestItemAsync. Notez que requestItemAsync() possède l'annotation @Trace(async=true), qui indique à l'agent de trace cette méthode si elle est liée à une transaction existante.

Une fois que parallelStream() a collecté tous les résultats, le jeton a expiré. Ceci est important car cela garantit que la transaction ne reste pas ouverte après la fin de parallelStream() .

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

Les API d'appelsagent dans cet exemple sont :

• @Trace(async = true): Démarre une transaction. Pour en savoir plus sur cette méthode, consultez la Javadoc.
• token.link(): Lie le travail effectué dans requestItemAsync() (qui s'exécute sur un thread différent) au thread demandeur. Pour en savoir plus sur cette méthode, consultez la Javadoc.

Pour afficher les détails de trace de la transaction, accédez à : one.newrelic.com APM & services > (select an app) > Transactions > Transaction trace > Trace details.

L'activité asynchrone est représentée dans la vue en cascade trace par des segments qui se chevauchent horizontalement, dans la dimension temporelle.

Il n'est pas nécessaire de lier les méthodes qui se trouvent sur le même thread, mais cela n'aura aucun effet négatif. Il arrive souvent qu'un seul jeton puisse être partagé, comme dans l'exemple parallelStream() .

La méthode ci-dessous effectue un appel à un service externe (dans ce cas une base de données) en utilisant la méthode 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);
    }
}

L'objectif dans ce cas est de déterminer combien de temps le Callable dans l'instruction Lambda attend dans le pool de threads avant de s'exécuter, plutôt que de déterminer combien de temps storeItem() s'exécute. Pour cette raison, un segment est utilisé à la place d'un jeton, et @Trace(async = true) n'est pas nécessaire comme c'était le cas pour un jeton.

L'API d'appelagent dans cet exemple est :

• @Trace(dispatcher = true): Démarre une transaction. Pour en savoir plus sur cette méthode, consultez la Javadoc.

L'exemple de code suivant montre un segment commençant par la méthode storeItem pour mesurer la durée d'attente de l'instruction Lambda dans le pool de threads. Pour arrêter le chronométrage du segment, vous devez appeler .end() ou .ignore(). Si vous don't souhaitez signaler le segment dans le cadre de sa transaction parent, appelez .ignore(). Sinon, pour signaler le segment comme faisant partie de sa transaction parent, appelez .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);
    });
}

Les API d'appelsagent dans cet exemple sont :

• startSegment(...): Commence le segment qui chronométrera le code. Pour en savoir plus sur cette méthode, consultez la Javadoc.
• reportAsExternal(DatastoreParameters()): Associe l'heure à un appel externe datastore Cela s'affichera dans APM avec les donnéesdatastore . Pour plus d'informations, consultez l'API reportAsExternal.
• segment.end(): Arrête le chronométrage de ce segment. Pour en savoir plus sur cette méthode, consultez la Javadoc.

Une fois la méthode terminée, APM affiche une trace de transaction avec un appel externe.