Application Real-Time Monitoring Service:Use ARMS to monitor asynchronous tasks

Monitor asynchronous tasks created by using the @Async annotation

Add a scan package for asynchronous pass-through

You can add a scan package for asynchronous pass-through to the configurations of your application to monitor asynchronous tasks. After a Runnable object, a Callable object, or a Supplier object is created, the corresponding method in the scan package for asynchronous pass-through automatically captures the trace context of the current thread. Then, when threads are used in asynchronous mode, the method passes the captured trace context to the threads.

1. Log on to the ARMS console. In the left-side navigation pane, choose Application Monitoring > Application List.

2. On the Application List page, select a region in the top navigation bar and click the name of the application that you want to manage.

   Note

   Icons displayed in the Language column indicate languages in which applications are written.

   : Java application

   : Go application

   : Python application

   Hyphen (-): application monitored in Managed Service for OpenTelemetry.

3. In the left-side navigation pane, click Application Settings. On the page that appears, click the Custom Configuration tab.

4. In the Advanced Settings section of the tab, enter the name of a scan package for asynchronous pass-through in the Asynchronous transparent transmission scan package name field.

   

5. Click Save.

package com.alibaba.arms.brightroar.console.service;

@Service
public class NameService {

    private ExecutorService es = Executors.newFixedThreadPool(5);

    public void name() {
        es.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println(System.currentTimeMillis()+ ": my name is john, " + Thread.currentThread().getId());
            }
        });
    }
}

Use an ARMS SDK to implement manual pass-through

If the preceding methods cannot meet your requirements in a complex monitoring scenario, you can use an ARMS SDK to implement manual pass-through. You can enhance the Runnable and Callable methods and executors to concatenate the traces in asynchronous threads to monitor asynchronous tasks.

1. Add the following dependency to the pom.xml file in your Maven project:

   <dependency>
    <groupId>com.alibaba.arms.apm</groupId>
    <version>1.7.5</version>
    <artifactId>arms-sdk</artifactId>
   </dependency>

2. Enhance the Runnable and Callable methods and executors as required. You can use one of the following enhancement methods as needed:

   Method 1: Enhance the Runnable and Callable methods

   Call the TraceRunnable.asyncEntry() method to enhance the Runnable method. Call the TraceCallable.asyncEntry() method to enhance the Callable method. The following code provides an example on how to enhance the Runnable and Callable methods:

   public class AsyncEntryExample {
   
       private final ExecutorService executor = Executors.newSingleThreadExecutor();
   
       @GetMapping(value = "/sdk-async-plugin/asyncEntry-propagation")
       public String asyncEntryAndExecute() throws Exception {
           CompletableFuture<String> future = new CompletableFuture<>();
           Runnable command = TraceRunnable.asyncEntry(() -> future.complete("asyncEntry-execute"));
           executor.execute(command);
           Thread.sleep(1000);
           return future.get();
       }
   }

   Method 2: Enhance the executors

   Call the TraceExecutors.wrapExecutorService(executor, true) method to enhance the executors. The following code provides an example on how to enhance the executors:

   public class AutoExample {
   
       private final ExecutorService contextPropagationExecutor
               = TraceExecutors.wrapExecutorService(Executors.newSingleThreadExecutor(), true);
   
       @GetMapping(value = "/sdk-async-plugin/auto-context-propagation")
       public String autoWrapAndExecute() throws Exception {
           CompletableFuture<String> future = new CompletableFuture<>();
           contextPropagationExecutor.execute(() -> future.complete("auto-execute"));
           Thread.sleep(1000);
           return future.get();
       }
   }

   Method 3: Enhance the Runnable and Callable methods and executors

   The following code provides an example on how to enhance the Runnable and Callable methods and executors:

   public class ManualExample {
       private final ExecutorService traceExecutor
               = TraceExecutors.wrapExecutorService(Executors.newSingleThreadExecutor());
   
       @GetMapping(value = "/sdk-async-plugin/manual-context-propagation")
       public String manualWrapAndExecute() throws Exception {
           CompletableFuture<String> future = new CompletableFuture<>();
           traceExecutor.execute(TraceRunnable.wrap(() -> future.complete("manual-execute")));
           traceExecutor.execute(() -> "Not captured");
           Thread.sleep(1000);
           return future.get();
       }
   }