Use loadtest4j 0.16.0 (#42)

Support decimal response time percentile queries.

Author: themasterchef

pom.xml

@@ -41,7 +41,7 @@
         <dependency>
             <groupId>org.loadtest4j</groupId>
             <artifactId>loadtest4j</artifactId>
-            <version>0.15.0</version>
+            <version>0.16.0</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>

src/main/java/org/loadtest4j/drivers/wrk/Wrk.java

@@ -9,14 +9,12 @@
 import org.loadtest4j.drivers.wrk.utils.*;
 import org.loadtest4j.drivers.wrk.utils.Process;
 
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
+import java.io.*;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Path;
 import java.time.Duration;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -61,12 +59,17 @@ private static Path createInput(List<DriverRequest> requests) {
         final List<Req> wrkRequests = wrkRequests(requests);
         final Input input = new Input(wrkRequests);
         final Path inputPath = FileUtils.createTempFile("loadtest4j-wrk", ".json");
-        Json.serialize(inputPath.toFile(), input);
+        try {
+            Json.serialize(inputPath.toFile(), input);
+        } catch (IOException e) {
+            throw new LoadTesterException(e);
+        }
         return inputPath;
     }
 
     private DriverResult runWrkViaShell(Path input) {
         final Path luaScript = createLuaScript();
+        final Path luaOutput = FileUtils.createTempFile("loadtest4j-output", ".json");
 
         final List<String> arguments = new ArgumentBuilder()
                 .addNamedArgument("--connections", valueOf(connections))
@@ -77,25 +80,38 @@ private DriverResult runWrkViaShell(Path input) {
                 .addArgument(input.toString())
                 .build();
 
-        final Command command = new Command(arguments, executable);
+        final Map<String, String> env = Collections.singletonMap("WRK_OUTPUT", luaOutput.toString());
+
+        final Command command = new Command(arguments, env, executable);
 
         final Process process = new Shell().start(command);
 
+        // Reduce sleep/wakeup cycles waiting for process by doing the sleep ourselves
+        try {
+            Thread.sleep(duration.toMillis());
+        } catch (InterruptedException e) {
+            // It was worth a try - just fall back to process.waitFor()
+        }
+
         final int exitStatus = process.waitFor();
 
         if (exitStatus != 0) {
             final String error = StreamReader.streamToString(process.getStderr());
             throw new LoadTesterException("Wrk error:\n\n" + error);
         }
 
-        try (Reader reader = new InputStreamReader(process.getStderr(), StandardCharsets.UTF_8)) {
-            return toDriverResult(reader);
+        try {
+            return toDriverResult(luaOutput.toAbsolutePath());
         } catch (IOException e) {
             throw new LoadTesterException(e);
         }
     }
 
-    protected static DriverResult toDriverResult(Reader report) {
+    private static DriverResult toDriverResult(Path path) throws IOException {
+        return toDriverResult(new InputStreamReader(new FileInputStream(path.toFile()), StandardCharsets.UTF_8));
+    }
+
+    protected static DriverResult toDriverResult(Reader report) throws IOException {
         final Output output = Json.parse(report, Output.class);
         return toDriverResult(output);
     }

src/main/java/org/loadtest4j/drivers/wrk/WrkResponseTime.java

@@ -2,24 +2,38 @@
 
 import org.loadtest4j.driver.DriverResponseTime;
 
+import java.math.BigDecimal;
 import java.time.Duration;
-import java.util.Map;
+import java.util.TreeMap;
 
 class WrkResponseTime implements DriverResponseTime {
 
-    private final Map<Integer, Long> percentiles;
+    private static final int DECIMAL_PLACES = 3;
 
-    WrkResponseTime(Map<Integer, Long> percentiles) {
+    private final TreeMap<BigDecimal, Long> percentiles;
+
+    WrkResponseTime(TreeMap<BigDecimal, Long> percentiles) {
         this.percentiles = percentiles;
     }
 
     @Override
-    public Duration getPercentile(int i) {
+    public Duration getPercentile(double i) {
         if (i < 0 || i > 100) {
             throw new IllegalArgumentException("A percentile must be between 0 and 100");
         }
 
-        final long durationMicroseconds = percentiles.get(i);
+        final BigDecimal decimalI = BigDecimal.valueOf(i);
+
+        if (decimalI.scale() > DECIMAL_PLACES) {
+            throw new IllegalArgumentException(String.format("The Wrk driver only supports percentile queries up to %d decimal places.", DECIMAL_PLACES));
+        }
+
+        final long durationMicroseconds;
+        try {
+            durationMicroseconds = percentiles.get(decimalI);
+        } catch (NullPointerException e) {
+            throw new IllegalArgumentException("The Wrk driver could not find a response time value for that percentile.");
+        }
 
         return Duration.ofNanos(durationMicroseconds * 1000);
     }

src/main/java/org/loadtest4j/drivers/wrk/WrkResult.java

@@ -4,7 +4,6 @@
 import org.loadtest4j.driver.DriverResult;
 
 import java.time.Duration;
-import java.util.Optional;
 
 class WrkResult implements DriverResult {
 
@@ -39,9 +38,4 @@ public Duration getActualDuration() {
     public DriverResponseTime getResponseTime() {
         return responseTime;
     }
-
-    @Override
-    public Optional<String> getReportUrl() {
-        return Optional.empty();
-    }
 }

src/main/java/org/loadtest4j/drivers/wrk/dto/Latency.java

@@ -3,14 +3,18 @@
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonProperty;
 
-import java.util.Map;
+import java.math.BigDecimal;
+import java.util.TreeMap;
 
 @JsonIgnoreProperties(ignoreUnknown = true)
 public class Latency {
+    /**
+     * A mapping of (the percentile, decimal) to (the percentile value).
+     */
     @JsonProperty
-    private Map<Integer, Long> percentiles;
+    private TreeMap<BigDecimal, Long> percentiles;
 
-    public Map<Integer, Long> getPercentiles() {
+    public TreeMap<BigDecimal, Long> getPercentiles() {
         return percentiles;
     }
 }

src/main/java/org/loadtest4j/drivers/wrk/utils/Command.java

@@ -2,21 +2,28 @@
 
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 
 public class Command {
 
     private final List<String> arguments;
+    private final Map<String, String> env;
     private final String launchPath;
 
-    public Command(List<String> arguments, String launchPath) {
+    public Command(List<String> arguments, Map<String, String> env, String launchPath) {
         this.arguments = arguments;
+        this.env = env;
         this.launchPath = launchPath;
     }
 
     public List<String> getArguments() {
         return Collections.unmodifiableList(arguments);
     }
 
+    public Map<String, String> getEnv() {
+        return env;
+    }
+
     public String getLaunchPath() {
         return launchPath;
     }

src/main/java/org/loadtest4j/drivers/wrk/utils/FileUtils.java

@@ -10,11 +10,16 @@
 
 public class FileUtils {
     public static Path createTempFile(String prefix, String suffix) {
+        final Path p;
         try {
-            return Files.createTempFile(prefix, suffix);
+            p = Files.createTempFile(prefix, suffix);
         } catch (IOException e) {
             throw new LoadTesterException(e);
         }
+
+        p.toFile().deleteOnExit();
+
+        return p;
     }
 
     public static void copy(InputStream content, Path target) {

src/main/java/org/loadtest4j/drivers/wrk/utils/Json.java

@@ -1,7 +1,6 @@
 package org.loadtest4j.drivers.wrk.utils;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.loadtest4j.LoadTesterException;
 
 import java.io.File;
 import java.io.IOException;
@@ -11,19 +10,11 @@ public class Json {
 
     private static final ObjectMapper MAPPER = new ObjectMapper();
 
-    public static void serialize(File resultFile, Object value) {
-        try {
-            MAPPER.writeValue(resultFile, value);
-        } catch (IOException e) {
-            throw new LoadTesterException(e);
-        }
+    public static void serialize(File resultFile, Object value) throws IOException {
+        MAPPER.writeValue(resultFile, value);
     }
 
-    public static <T> T parse(Reader src, Class<T> valueType) {
-        try {
-            return MAPPER.readValue(src, valueType);
-        } catch (IOException e) {
-            throw new LoadTesterException(e);
-        }
+    public static <T> T parse(Reader src, Class<T> valueType) throws IOException {
+        return MAPPER.readValue(src, valueType);
     }
 }

src/main/java/org/loadtest4j/drivers/wrk/utils/Shell.java

@@ -13,8 +13,11 @@ public org.loadtest4j.drivers.wrk.utils.Process start(Command command) {
         cmd.add(command.getLaunchPath());
         cmd.addAll(command.getArguments());
 
+        final ProcessBuilder pb = new ProcessBuilder(cmd)
+                .redirectInput(ProcessBuilder.Redirect.PIPE);
+        pb.environment().putAll(command.getEnv());
         try {
-            return new org.loadtest4j.drivers.wrk.utils.Process(new ProcessBuilder(cmd).redirectInput(ProcessBuilder.Redirect.PIPE).start());
+            return new org.loadtest4j.drivers.wrk.utils.Process(pb.start());
         } catch (IOException e) {
             throw new LoadTesterException(e);
         }

src/main/resources/loadtest4j-wrk.lua

@@ -40,14 +40,40 @@ done = function(summary, latency, requests)
         }
     }
 
-    for p = 0, 99
+    -- WARNING: decimalPlaces has a connascence with granularity. If you change one you MUST change the other.
+    local granularity = 0.001
+    local decimalPlaces = 3
+
+    for p = 0, 100, granularity
     do
-        json["latency"]["percentiles"][p] = latency:percentile(p)
+        -- We must round to the desired decimal places to stop p losing accuracy (e.g. the p95.9 becomes p95.8999999999)
+        local roundedP = round(p, decimalPlaces)
+        json["latency"]["percentiles"][roundedP] = latency:percentile(roundedP)
     end
+
     -- p100 is not available so use max instead
     json["latency"]["percentiles"][100] = latency.max
 
-    io.stderr:write(encodeJson(json))
+    printReport(encodeJson(json))
+end
+
+function printReport(report)
+    local outputFile = os.getenv("WRK_OUTPUT")
+    if outputFile == nil then
+        io.stderr:write(report)
+    else
+        local fho, _ = io.open(outputFile, "w")
+        fho:write(report)
+        fho:close()
+    end
+end
+
+-- From https://stackoverflow.com/a/37792884/1475135
+function round(x, n)
+    n = math.pow(10, n)
+    x = x * n
+    if x >= 0 then x = math.floor(x + 0.5) else x = math.ceil(x - 0.5) end
+    return x / n
 end
 
 function readFile(file)