Showing results for 
Show  only  | Search instead for 
Did you mean: 

PurePaths lacks detail when using Java Futures coding technique


We have an report generation operation which consumes a
request off of a queue (kinda like MDB) and then will call many longish running
downstream web services (think that the average response time for these web
services might be 2 seconds.) It was architected the way it was because
we knew that overall time it took to generate the report was going to take some
time so we wanted it to be async in nature.

We are using a coding technique called
Futures. I give a code example below. My understanding is that

  1. We actually start the call on this
    line. My understanding is that the call out to the downstream web service
    gets handed into a pool of threads (NOT the calling thread) and when there is
    availability the request will be sent. This uses Java NIO so it will
    detect when the response comes back.
  2. Finally when the response comes back (assuming
    it is a successful response) then the callback will be called (in the context
    of another thread other than the NIO pool of threads.)

private ListenableFuture<List<PerformanceSubject>>
loadSubjects(BookTask task) {final AccountRelationship accountRelationship = new AccountRelationship();


ListenableFuture<Accounts> details = entitySearchClient.getDetailAccountsAsync(task.getFaNumbers(),



Futures.addCallback(details, new FutureCallback<Accounts>()
{@Overridepublic void onSuccess(Accounts
result) {accountRelationship.setAccounts(result);


@Overridepublic void onFailure(Throwable
t) {LOGGER.error(t.getMessage(),




challenge is that we don’t see the calls out to any of the downsteam services
or the time being spent there. In the pure path they just show up as "Code Path not instrumented"


Dynatrace Guru
Dynatrace Guru

Hi Jeff

I think you had an email conversation with one of our software architects. anything you can share based on that conversation?