How to remove the time measurement logic

Question

I need to calculate the execution time of some methods. These are private methods in the class, so Spring AOP is not appropriate. Now the code looks like this.

   public void method() {
       StopWatch sw = new StopWatch();
       sw.start();
       innerMethod1();
       sw.stop();
       Monitoring.add("eventType1", sw.getLastTaskTimeMillis());

       sw.start();
       innerMethod2("abs");
       sw.stop();
       Monitoring.add("eventType2", sw.getLastTaskTimeMillis());

       sw.start();
       innerMethod3(5, 29);
       sw.stop();
       Monitoring.add("eventType3", sw.getLastTaskTimeMillis());
   }

But inserts with time measurement fit into the business logic. Are there any solutions? These data will be then recorded in the database for grafana. I'm looking towards AspectJ, but I can't pass keys when starting the app.

When class instrumentation is required in environments that do not support or are not supported by the existing LoadTimeWeaver implementations, a JDK agent can be the only solution. For such cases, Spring provides InstrumentationLoadTimeWeaver, which requires a Spring-specific (but very general) VM agent,org.springframework.instrument-{version}.jar (previously named spring-agent.jar). To use it, you must start the virtual machine with the Spring agent, by supplying the following JVM options: -javaagent:/path/to/org.springframework.instrument-{version}.jar

---

to Mark Bramnik If I understand you correctly, then for methods

   private List<String> innerMethod3(int value, int count) {
       //
   }

   private String innerMethod2(String event)  {
       //
   }

need methods

   public  <T, R, U> U timed(T value, R count, BiFunction<T, R, U> function) {
       long start = System.currentTimeMillis();
       U result = function.apply(value, count);
       Monitoring.add("method", System.currentTimeMillis() - start);
       return result;
   }

   public <T, R> R timed(T value, Function<T, R> function) {
       long start = System.currentTimeMillis();
       R result = function.apply(value);
       Monitoring.add("method", System.currentTimeMillis() - start);
       return result;
   }

And calling methods:

       List<String> timed = timed(5, 5, this::innerMethod3);
       String string = timed("string", this::innerMethod2);

But if method4 has 4 parameters, then I need a new method for measuring time and a new functional interface

Answer 1

There are many approaches you can take but all will boil down to refactoring.

Approach 1:

class Timed {

    public static  void timed(String name, Runnable codeBlock) {
        long from = System.currentTimeMillis();
        codeBlock.run();
        long to = System.currentTimeMillis();
        System.out.println("Monitored: " + name + " : " + (to - from) + " ms");
    }

    public static <T> T timed(String name, Supplier<T> codeBlock)  {
        long from = System.currentTimeMillis();
        T result = codeBlock.get();
        long to = System.currentTimeMillis();
        System.out.println("Monitored: " + name + " : " + (to - from) + " ms");
        return result;
    }
}

Notes:

• I've used Runnable / Supplier interfaces for simplicity you might want to create your own functional interfaces for this.
• I've used System.out - you'll use the existing Monitoring.add call instead

The aforementioned code can be used like this:

 Timed.timed("sample.runnable", ()-> { // Timed. can be statically imported for even further brevity
      // some code block here
 });
 // will measure

int result = Timed.timed("sample.callable", () -> 42);
// will measure and result will be 42

Another approach.

Refactor the code to public methods and integrate with Micrometer that already has annotations support (see @Timed).

I don't know what Monitoring is but micrometer already contains both integration with Prometheus (and other similar products that can store the metrics and later on used from grafana) + it keeps in memory the mathematical model of your measurements and doesn't keep in memory the information per each measurement. In the custom implementation its a complicated code to maintain.

Update 1

No, you got it wrong, you don't need to maintain different versions of timed - you need only two versions that I've provided in the solution. In the case that you've presented in the question, you won't even need the second version of timed.

Your code will become:

public void method() {
       
       Timed.timed("eventType1", () -> {
          innerMethod1();
       });

  
       Timed.timed("eventType2", () -> {    
           innerMethod2("abs");
       });
     
       Timed.timed("eventType3", () -> {    
          innerMethod3(5, 29);
       });
         
   }

The second version is required for the cases where you actually return some value from the "timed" code:

Example: Lets say you have innerMethod4 that returns String, so you'll write the following code:

    String result = Timed.timed("eventType3", () -> {    
        return innerMethod4(5, 29);
    });