TracerAspect.java

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package br.ufrgs.inf.prosoft.applicationtracer;

import br.ufrgs.inf.prosoft.jsonserialiser.JSONSerialiser;
import br.ufrgs.inf.prosoft.trace.Parameter;
import br.ufrgs.inf.prosoft.trace.Return;
import br.ufrgs.inf.prosoft.trace.Trace;
import br.ufrgs.inf.prosoft.trace.TraceConcrete;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

/**
 *
 * @author romulo
 */
@Aspect
public class TracerAspect {

    @Pointcut("execution(!void *(..)) && !within(br.ufrgs.inf.prosoft.applicationtracer..*)")
    public void anyMethodExecution() {
    }

    @Around("anyMethodExecution()")
    public Object serializeMethodCall(ProceedingJoinPoint joinPoint) throws Throwable {
        String enableTracer = System.getenv("TRACER_ENABLE");
        if (enableTracer != null && !enableTracer.equals("true")) {
            return joinPoint.proceed();
        }
        long startTime = System.currentTimeMillis();
        Object proceed = joinPoint.proceed();
        long endTime = System.currentTimeMillis();
        if (startTime == endTime) {
            return proceed;
        }
        String longsignature = joinPoint.getSignature().toLongString();
        if (longsignature.contains("AjcClosure")) {
            return proceed;
        }
        String blacklistPath = System.getenv("TRACER_BLACKLIST");
        if (blacklistPath == null) {
            blacklistPath = "./blacklist";
        }
        List<String> blacklist;
        try {
            blacklist = Files.readAllLines(Paths.get(blacklistPath));
        } catch (IOException ex) {
            blacklist = new ArrayList<>();
        }
        if (blacklist.contains(longsignature)) {
            System.out.println("[ApplicationTracer] skipping " + longsignature);
            return proceed;
        }
        try {
            boolean verbose = endTime - startTime > 5;
            if (verbose) {
                String verboseTracer = System.getenv("TRACER_VERBOSE");
                if (verboseTracer != null && verboseTracer.equals("false")) {
                    verbose = false;
                }
            }
            if (verbose) {
                System.out.print("[ApplicationTracer] tracing " + longsignature + "... ");
            }
            String[] split = longsignature.substring(0, longsignature.length() - 1).split("\\(");
            String[] modifiersReturnAndName = split[0].split(" ");
            String[] modifiers = Arrays.copyOf(modifiersReturnAndName, modifiersReturnAndName.length - 2);
            String methodName = modifiersReturnAndName[modifiersReturnAndName.length - 1];
            String returnType = modifiersReturnAndName[modifiersReturnAndName.length - 2];
            List<Parameter> parameters = new ArrayList<>();
            if (split.length > 1) {
                String[] parameterTypes = split[1].split(", ");
                Object[] parametersData = joinPoint.getArgs();
                for (int i = 0; i < parametersData.length; i++) {
                    parameters.add(new Parameter(parameterTypes[i], parametersData[i]));
                }
            }
            Return returnValue = new Return(returnType, proceed);
            String instance;
            try {
                instance = String.valueOf(joinPoint.getThis().hashCode());
            } catch (Exception ex) {
                instance = "s";
            }
            String userId = getUserId();
            Trace trace = new TraceConcrete(instance, Arrays.asList(modifiers), returnValue, methodName, parameters, startTime, endTime, userId);
            String tracesPath = System.getenv("TRACER_TRACES");
            if (tracesPath == null) {
                tracesPath = "./traces";
            }
            synchronized (TracerAspect.class) {
                if (verbose) {
                    System.out.print(System.currentTimeMillis() + "... ");
                }
                ExecutorService service = Executors.newSingleThreadExecutor();
                Future<String> futureTrace = service.submit(() -> {
                    String jsonTrace = JSONSerialiser.serialise(trace);
                    jsonTrace += "\n";
                    return jsonTrace;
                });
                String jsonTrace;
                try {
                    jsonTrace = futureTrace.get(20, TimeUnit.SECONDS);
                    if (verbose) {
                        System.out.print(System.currentTimeMillis() + "... ");
                    }
                    try (FileWriter fileWriter = new FileWriter(tracesPath, true)) {
                        fileWriter.write(jsonTrace);
                    }
                    if (verbose) {
                        System.out.println(System.currentTimeMillis());
                    }
                } catch (TimeoutException ex) {
                    System.err.println("[ApplicationTracer] tracing timeout on " + longsignature);
                }
            }
        } catch (Exception ex) {
            System.err.println("[ApplicationTracer] exception: " + ex);
        }
        return proceed;
    }

    private String getUserId() {
        try {
            Object contextHolder = Class.forName("org.springframework.security.core.context.SecurityContextHolder").newInstance();
            Object context = contextHolder.getClass().getMethod("getContext").invoke(contextHolder);
            Object auth = context.getClass().getMethod("getAuthentication").invoke(context);
            return (String) auth.getClass().getMethod("getName").invoke(auth);
        } catch (Exception ex) {
            return "";
        }
    }
}