├── README.txt
├── pom.xml
└── src
    └── main
        ├── java
            └── com
            │   └── mycompany
            │       └── app
            │           ├── PerformanceTest.java
            │           ├── model
            │               └── TaxRate.java
            │           ├── servlets
            │               ├── DatabaseServlet.java
            │               └── PlainJavaServlet.java
            │           └── util
            │               ├── MyProperties.java
            │               └── UpdatePlot.java
        └── resources
            ├── application.properties
            ├── database.sql
            ├── plot_template.html
            └── simplelogger.properties


/README.txt:
--------------------------------------------------------------------------------
 1 | The servers/AMIs need:
 2 | 
 3 | * Java installed (11+)
 4 | * An SSH key on your machine, added to your ssh-agent, whose username matches with the SSH username in PerformanceTest#main()
 5 | * The sar and mpstat utilities installed ->
 6 |     * Ubuntu: sudo apt install sysstat
 7 | * For Flamegraphs to work ->
 8 |     * JDK Debug symbols: https://github.com/jvm-profiling-tools/async-profiler#installing-debug-symbols
 9 |     * Allow capturing Kernel call stack events:  https://github.com/jvm-profiling-tools/async-profiler#basic-usage
10 | 
11 | If you want to use a database for testing:
12 | 
13 | * Create an RDS database and add its properties to application.properties
14 | * Execute database.sql against your new RDS database
15 | * Change MODE in PerformanceTest to "DEPLOY_DB"


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | 
  3 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4 |          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5 |     <modelVersion>4.0.0</modelVersion>
  6 | 
  7 |     <groupId>com.mycompany.app</groupId>
  8 |     <artifactId>performance-testing</artifactId>
  9 |     <version>1.0-SNAPSHOT</version>
 10 | 
 11 |     <name>performance-testing</name>
 12 |     <!-- FIXME change it to the project's website -->
 13 |     <url>http://www.example.com</url>
 14 | 
 15 |     <properties>
 16 |         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 17 |         <maven.compiler.source>17</maven.compiler.source>
 18 |         <maven.compiler.target>17</maven.compiler.target>
 19 |     </properties>
 20 | 
 21 |     <dependencies>
 22 | 
 23 |         <!-- https://mvnrepository.com/artifact/commons-codec/commons-codec -->
 24 |         <dependency>
 25 |             <groupId>commons-codec</groupId>
 26 |             <artifactId>commons-codec</artifactId>
 27 |             <version>1.15</version>
 28 |         </dependency>
 29 | 
 30 |         <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
 31 |         <dependency>
 32 |             <groupId>org.apache.commons</groupId>
 33 |             <artifactId>commons-lang3</artifactId>
 34 |             <version>3.12.0</version>
 35 |         </dependency>
 36 | 
 37 |         <dependency>
 38 |             <groupId>org.mortbay.jetty.orchestrator</groupId>
 39 |             <artifactId>jetty-cluster-orchestrator</artifactId>
 40 |             <version>1.0.3</version>
 41 |         </dependency>
 42 |         <!-- https://mvnrepository.com/artifact/org.mortbay.jetty.loadgenerator/jetty-load-generator-client -->
 43 |         <dependency>
 44 |             <groupId>org.mortbay.jetty.loadgenerator</groupId>
 45 |             <artifactId>jetty-load-generator-listeners</artifactId>
 46 |             <version>3.1.1</version>
 47 |         </dependency>
 48 |         <dependency>
 49 |             <groupId>org.mortbay.jetty.loadgenerator</groupId>
 50 |             <artifactId>jetty-load-generator-client</artifactId>
 51 |             <version>3.1.1</version>
 52 |         </dependency>
 53 |         <!-- https://mvnrepository.com/artifact/org.hdrhistogram/HdrHistogram -->
 54 |         <dependency>
 55 |             <groupId>org.hdrhistogram</groupId>
 56 |             <artifactId>HdrHistogram</artifactId>
 57 |             <version>2.1.12</version>
 58 |         </dependency>
 59 |         <!-- https://mvnrepository.com/artifact/org.eclipse.jetty.toolchain/jetty-perf-helper -->
 60 |         <dependency>
 61 |             <groupId>org.eclipse.jetty.toolchain</groupId>
 62 |             <artifactId>jetty-perf-helper</artifactId>
 63 |             <version>1.0.7</version>
 64 |         </dependency>
 65 | 
 66 |         <dependency>
 67 |             <groupId>org.eclipse.jetty</groupId>
 68 |             <artifactId>jetty-server</artifactId>
 69 |             <version>11.0.8</version>
 70 |         </dependency>
 71 |         <dependency>
 72 |             <groupId>org.eclipse.jetty</groupId>
 73 |             <artifactId>jetty-servlet</artifactId>
 74 |             <version>11.0.8</version>
 75 |         </dependency>
 76 |         <dependency>
 77 |             <groupId>com.zaxxer</groupId>
 78 |             <artifactId>HikariCP</artifactId>
 79 |             <version>5.0.1</version>
 80 |         </dependency>
 81 |         <dependency>
 82 |             <groupId>mysql</groupId>
 83 |             <artifactId>mysql-connector-java</artifactId>
 84 |             <version>8.0.28</version>
 85 |         </dependency>
 86 | 
 87 |         <dependency>
 88 |             <groupId>org.slf4j</groupId>
 89 |             <artifactId>slf4j-simple</artifactId>
 90 |             <version>2.0.0-alpha6</version>
 91 |         </dependency>
 92 |         <dependency>
 93 |             <groupId>org.mortbay.jetty.perf</groupId>
 94 |             <artifactId>jetty-perf</artifactId>
 95 |             <version>1.0.0-SNAPSHOT</version>
 96 |             <exclusions>
 97 |                 <exclusion>
 98 |                     <groupId>ch.qos.logback</groupId>
 99 |                     <artifactId>logback-classic</artifactId>
100 |                 </exclusion>
101 |             </exclusions>
102 |         </dependency>
103 | 
104 |         <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-simple -->
105 |         <dependency>
106 |             <groupId>org.slf4j</groupId>
107 |             <artifactId>slf4j-simple</artifactId>
108 |             <version>2.0.0-alpha6</version>
109 | 
110 |         </dependency>
111 | 
112 | 
113 |     </dependencies>
114 | 
115 | </project>
116 | 


--------------------------------------------------------------------------------
/src/main/java/com/mycompany/app/PerformanceTest.java:
--------------------------------------------------------------------------------
  1 | package com.mycompany.app;
  2 | 
  3 | import com.mycompany.app.servlets.DatabaseServlet;
  4 | import com.mycompany.app.servlets.PlainJavaServlet;
  5 | import org.HdrHistogram.AbstractHistogram;
  6 | import org.HdrHistogram.Histogram;
  7 | import org.HdrHistogram.HistogramLogReader;
  8 | import org.apache.commons.io.IOUtils;
  9 | import org.eclipse.jetty.perf.histogram.loader.ResponseStatusListener;
 10 | import org.eclipse.jetty.perf.histogram.loader.ResponseTimeListener;
 11 | import org.eclipse.jetty.perf.histogram.server.LatencyRecordingChannelListener;
 12 | import org.eclipse.jetty.perf.monitoring.ConfigurableMonitor;
 13 | import org.eclipse.jetty.perf.util.ReportUtil;
 14 | import org.eclipse.jetty.server.Connector;
 15 | import org.eclipse.jetty.server.Server;
 16 | import org.eclipse.jetty.server.ServerConnector;
 17 | import org.eclipse.jetty.server.handler.DefaultHandler;
 18 | import org.eclipse.jetty.server.handler.HandlerList;
 19 | import org.eclipse.jetty.servlet.ServletContextHandler;
 20 | import org.eclipse.jetty.servlet.ServletHolder;
 21 | import org.mortbay.jetty.load.generator.LoadGenerator;
 22 | import org.mortbay.jetty.load.generator.Resource;
 23 | import org.mortbay.jetty.orchestrator.Cluster;
 24 | import org.mortbay.jetty.orchestrator.ClusterTools;
 25 | import org.mortbay.jetty.orchestrator.NodeArray;
 26 | import org.mortbay.jetty.orchestrator.NodeArrayFuture;
 27 | import org.mortbay.jetty.orchestrator.configuration.*;
 28 | import org.slf4j.Logger;
 29 | import org.slf4j.LoggerFactory;
 30 | 
 31 | import java.io.*;
 32 | import java.net.URI;
 33 | import java.net.http.HttpClient;
 34 | import java.net.http.HttpRequest;
 35 | import java.net.http.HttpResponse;
 36 | import java.nio.file.Files;
 37 | import java.nio.file.Path;
 38 | import java.nio.file.Paths;
 39 | import java.text.SimpleDateFormat;
 40 | import java.time.Duration;
 41 | import java.util.*;
 42 | import java.util.concurrent.CompletableFuture;
 43 | import java.util.concurrent.ConcurrentMap;
 44 | import java.util.concurrent.TimeUnit;
 45 | import java.util.stream.Collectors;
 46 | 
 47 | /**
 48 |  * Hello world!
 49 |  */
 50 | public class PerformanceTest {
 51 | 
 52 | 
 53 |     /**
 54 |      * RPS
 55 |      */
 56 | 
 57 |     /** e.g. play with
 58 |      * 250  (x 4 = 1000)
 59 |      * 1250 (x 4 = 5000)
 60 |      * 5000 (x 4 = 20000)
 61 |      * 7500 (x 4 = 30000)
 62 |      * 10000(x 4 = 40000)
 63 |      */
 64 | 
 65 |     private static final int RPS_LOADER = 2500;
 66 |     public static final int RPS_PROBE = 2;
 67 | 
 68 | 
 69 |     /**
 70 |      * --------- IPS --------------
 71 |      */
 72 | 
 73 |     public static final String SERVER_IP = "3.68.71.212";
 74 | 
 75 |     public static final String PROBE_IP = "3.122.97.183";
 76 | 
 77 | 
 78 |     public static List<String> LOADER_IPS = List.of("18.185.2.251", "3.125.157.86", "3.67.75.104", "3.71.75.125");
 79 | 
 80 | 
 81 |     /**
 82 |      * --------- PARAMS --------------
 83 |      */
 84 |     private static Mode mode = Mode.MANUAL;
 85 | 
 86 | 
 87 | 
 88 |     private static final Duration WARMUP_DURATION = Duration.ofSeconds(30);
 89 |     private static final Duration RUN_DURATION = Duration.ofSeconds(60);
 90 | 
 91 |     public static final String BASE_FOLDER = ".\\target\\results";
 92 | 
 93 |     public static final Resource REQUEST_URI = new Resource("/tax-html-freemarker");
 94 |     public static final int PORT = 8080;
 95 | 
 96 | 
 97 |     public enum Mode {
 98 |         DEPLOY_JAVA, DEPLOY_DB, MANUAL
 99 |     }
100 | 
101 |     private static Logger LOGGER = LoggerFactory.getLogger(PerformanceTest.class);
102 | 
103 | 
104 |     private static final EnumSet<ConfigurableMonitor.Item> MONITORED_ITEMS = EnumSet.of(
105 |             ConfigurableMonitor.Item.CMDLINE_CPU,
106 |             ConfigurableMonitor.Item.CMDLINE_MEMORY,
107 |             ConfigurableMonitor.Item.CMDLINE_NETWORK
108 |     );
109 | 
110 |     private static final EnumSet<ConfigurableMonitor.Item> SERVER_ITEMS = copy(MONITORED_ITEMS,
111 |             ConfigurableMonitor.Item.ASYNC_PROF_CPU,
112 |             ConfigurableMonitor.Item.JHICCUP);
113 | 
114 | 
115 |     public static void main(String[] args) throws IOException {
116 |         // set SSH username here
117 |         System.setProperty("user.name", "ubuntu");
118 | 
119 |         Files.createDirectories(Paths.get(BASE_FOLDER));
120 | 
121 |         SimpleNodeArrayConfiguration probeConfig = probeConfig();
122 |         SimpleNodeArrayConfiguration loadGeneratorConfig = loaderConfig();
123 |         SimpleNodeArrayConfiguration serverConfig = serverConfig();
124 | 
125 |         SimpleClusterConfiguration cfg = new SimpleClusterConfiguration()
126 |                 .jvm(new Jvm((fs, h) -> "/usr/bin/java", "-Xmx3g"))
127 |                 .nodeArray(probeConfig)
128 |                 .nodeArray(serverConfig)
129 |                 .nodeArray(loadGeneratorConfig);
130 | 
131 | 
132 | 
133 |         int participantCount = cfg.nodeArrays().stream().mapToInt(na -> na.nodes().size()).sum() + 1; // + 1 b/c of the test its.
134 | 
135 |         try (Cluster cluster = new Cluster(cfg)) {
136 |             NodeArray serverArray = cluster.nodeArray("server");
137 |             NodeArray loadersArray = cluster.nodeArray("load-generator");
138 |             NodeArray probeArray = cluster.nodeArray("probe");
139 | 
140 |             serverArray.executeOnAll(tools -> startServer(tools.nodeEnvironment())).get(30, TimeUnit.SECONDS);
141 |             loadersArray.executeOnAll(tools -> runLoadGenerator(tools.nodeEnvironment())).get(30, TimeUnit.SECONDS);
142 |             probeArray.executeOnAll(tools -> runProbe(tools.nodeEnvironment())).get(30, TimeUnit.SECONDS);
143 | 
144 |             LOGGER.info("Warming up...");
145 |             Thread.sleep(WARMUP_DURATION.toMillis());
146 | 
147 |             LOGGER.info("Running...");
148 |             //long before = System.nanoTime();
149 | 
150 |             NodeArrayFuture serverFuture = serverArray.executeOnAll(tools -> recordServerMetrics(participantCount, tools));
151 |             NodeArrayFuture loadersFuture = loadersArray.executeOnAll(tools -> recordClientMetrics(participantCount, tools));
152 |             NodeArrayFuture probeFuture = probeArray.executeOnAll(tools -> recordClientMetrics(participantCount, tools));
153 | 
154 | 
155 |             try {
156 |                 // signal all participants to start
157 |                 cluster.tools().barrier("run-start-barrier", participantCount).await(30, TimeUnit.SECONDS);
158 |                 // wait for the run duration
159 |                 Thread.sleep(RUN_DURATION.toMillis());
160 |                 // signal all participants to stop
161 |                 cluster.tools().barrier("run-end-barrier", participantCount).await(30, TimeUnit.SECONDS);
162 |             } finally {
163 |                 // wait for all report files to be written;
164 |                 // do it in a finally so that if the above barrier awaits time out b/c a job threw an exception
165 |                 // the future.get() call will re-throw the exception and it'll be logged.
166 |                 try {
167 |                     serverFuture.get(30, TimeUnit.SECONDS);
168 |                     probeFuture.get(30, TimeUnit.SECONDS);
169 |                     loadersFuture.get(30, TimeUnit.SECONDS);
170 |                 } catch (Exception e){
171 |                     e.printStackTrace();
172 |                 }
173 |             }
174 | 
175 |             // stop server
176 |             serverArray.executeOnAll((tools) -> stopServer(tools.nodeEnvironment())).get(60, TimeUnit.SECONDS);
177 | 
178 |             downloadReports(cluster, probeConfig, loadGeneratorConfig);
179 |         } catch (Exception e) {
180 |             e.printStackTrace();
181 |         }
182 |     }
183 | 
184 |     private static SimpleNodeArrayConfiguration loaderConfig() {
185 |         SimpleNodeArrayConfiguration loadGeneratorConfig = new SimpleNodeArrayConfiguration("load-generator");
186 | 
187 |         LOADER_IPS.forEach(ip -> {
188 |             loadGeneratorConfig.node(new Node("loader-" + toDirectoryName(ip), ip));
189 |         });
190 |         return loadGeneratorConfig;
191 |     }
192 | 
193 |     private static SimpleNodeArrayConfiguration probeConfig() {
194 |         return new SimpleNodeArrayConfiguration("probe")
195 |                 .node(new Node("probe-" + toDirectoryName(PROBE_IP), PROBE_IP));
196 |     }
197 | 
198 |     private static String toDirectoryName(String ip) {
199 |         return ip.replaceAll("\\.", "-");
200 |     }
201 | 
202 |     private static SimpleNodeArrayConfiguration serverConfig() {
203 |         return new SimpleNodeArrayConfiguration("server")
204 |                 .node(new Node("server-" + toDirectoryName(SERVER_IP), SERVER_IP));
205 |     }
206 | 
207 |     private static void downloadReports(Cluster cluster, SimpleNodeArrayConfiguration probeConfig, SimpleNodeArrayConfiguration loadGeneratorConfig) throws IOException {
208 |         String dateTimeString = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
209 |         Path targetPath = Paths.get(BASE_FOLDER).resolve(dateTimeString);
210 | 
211 |         List<NodeArray> nodeArrays = List.of(cluster.nodeArray("server"),
212 |                 cluster.nodeArray("load-generator"),
213 |                 cluster.nodeArray("probe"));
214 |         for (NodeArray nodeArray : nodeArrays) {
215 | 
216 |             ReportUtil.download(nodeArray, targetPath);
217 |             ReportUtil.transformPerfHisto(nodeArray, targetPath);
218 |             ReportUtil.transformJHiccupHisto(nodeArray, targetPath);
219 |             transformAndAddToPlot(dateTimeString, nodeArray, targetPath);
220 |         }
221 | 
222 |         long totalLoadersRequestCount = RPS_LOADER * LOADER_IPS.size() * RUN_DURATION.toSeconds();
223 |         assertThroughput(targetPath, loadGeneratorConfig, totalLoadersRequestCount, 1);
224 | 
225 |         long totalProbeRequestCount = RPS_PROBE * 1 * RUN_DURATION.toSeconds();
226 |         assertThroughput(targetPath, probeConfig, totalProbeRequestCount, 1);
227 |     }
228 | 
229 |     private static void transformAndAddToPlot(String dateTimeString, NodeArray nodeArray, Path targetPath) {
230 |         nodeArray.ids().stream().filter(id -> id.startsWith("probe")).forEach(id -> {
231 |             Path plotFolder = Paths.get(BASE_FOLDER).resolve("plot");
232 |             if (!Files.exists(plotFolder)) {
233 |                 try {
234 |                     Files.createDirectories(plotFolder);
235 |                 } catch (IOException e) {
236 |                     e.printStackTrace();
237 |                 }
238 |             }
239 |             try {
240 |                 Files.copy(targetPath.resolve(id).resolve("perf.hlog.hgrm"), plotFolder.resolve(dateTimeString + "_" + LOADER_IPS.size() + "x" + RPS_LOADER + ".hlog.hgrm"));
241 |                 updatePlot(plotFolder);
242 |             } catch (IOException e) {
243 |                 System.err.println(e.toString());
244 |                 e.printStackTrace();
245 |             }
246 |         });
247 |     }
248 | 
249 |     private static void recordServerMetrics(int participantCount, ClusterTools tools) throws Exception {
250 |         EnumSet<ConfigurableMonitor.Item> items = isAutoDeploy() ? SERVER_ITEMS : MONITORED_ITEMS;
251 | 
252 |         HttpClient httpClient = HttpClient.newHttpClient();
253 | 
254 | 
255 |         try (ConfigurableMonitor ignore = new ConfigurableMonitor(items)) {
256 |             LatencyRecordingChannelListener listener = null;
257 |             if (isAutoDeploy()) {
258 |                 listener = (LatencyRecordingChannelListener) tools.nodeEnvironment().get(LatencyRecordingChannelListener.class.getName());
259 |                 listener.startRecording();
260 |             } else {
261 |                 HttpRequest request = HttpRequest.newBuilder()
262 |                         .POST(HttpRequest.BodyPublishers.noBody())
263 |                         .uri(URI.create("http://localhost:8080/performance-metrics/start?mode=cpu"))
264 |                         .setHeader("User-Agent", "Java 11 HttpClient Bot") // add request header
265 |                         .build();
266 | 
267 |                 HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
268 |                 // print status code
269 |                 System.out.println("Starting metrics collection on server.  Response Code = " + response.statusCode() + " | Response: " + response.body());
270 |             }
271 |             tools.barrier("run-start-barrier", participantCount).await();
272 |             tools.barrier("run-end-barrier", participantCount).await();
273 |             if (isAutoDeploy()) {
274 |                 listener.stopRecording();
275 |             } else {
276 |                 HttpRequest request = HttpRequest.newBuilder()
277 |                         .POST(HttpRequest.BodyPublishers.noBody())
278 |                         .uri(URI.create("http://localhost:8080/performance-metrics/stop"))
279 |                         .setHeader("User-Agent", "Java 11 HttpClient Bot") // add request header
280 |                         .build();
281 | 
282 |                 HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
283 |                 // print status code
284 |                 System.out.println("Stopping metrics collection on server. Response Code =  " + response.statusCode() + " | Response: " + response.body());
285 |             }
286 |         }
287 |     }
288 | 
289 |     private static void recordClientMetrics(int participantCount, ClusterTools tools) throws Exception {
290 |         try (ConfigurableMonitor ignore = new ConfigurableMonitor(MONITORED_ITEMS)) {
291 |             ResponseTimeListener responseTimeListener = (ResponseTimeListener) tools.nodeEnvironment().get(ResponseTimeListener.class.getName());
292 |             responseTimeListener.startRecording();
293 |             ResponseStatusListener responseStatusListener = (ResponseStatusListener) tools.nodeEnvironment().get(ResponseStatusListener.class.getName());
294 |             responseStatusListener.startRecording();
295 |             tools.barrier("run-start-barrier", participantCount).await();
296 |             tools.barrier("run-end-barrier", participantCount).await();
297 |             responseTimeListener.stopRecording();
298 |             responseStatusListener.stopRecording();
299 |             CompletableFuture<?> cf = (CompletableFuture<?>) tools.nodeEnvironment().get(CompletableFuture.class.getName());
300 |             cf.get();
301 |         }
302 |     }
303 | 
304 |     private static boolean isAutoDeploy() {
305 |         return mode == Mode.DEPLOY_DB | mode == Mode.DEPLOY_JAVA;
306 |     }
307 | 
308 | 
309 | 
310 |     private static void startServer(ConcurrentMap<String, Object> env) throws Exception {
311 |         if (mode.equals(Mode.MANUAL)) {
312 |             startPreDeployedServer(env);
313 |         }
314 |         else {
315 |             autoDeployServer(env);
316 |         }
317 |     }
318 | 
319 | 
320 | 
321 |     private static void startPreDeployedServer(ConcurrentMap<String, Object> env) {
322 |         try {
323 |         Process process = new ProcessBuilder("/usr/bin/java", "-jar", "/home/ubuntu/spring-performance-0.0.1-SNAPSHOT.jar", "&").start();
324 |       //      Process process = new ProcessBuilder("/usr/bin/java", "-jar", "/home/ubuntu/spring-petclinic-3.0.0-SNAPSHOT.jar", "&").start();
325 |             env.put(Process.class.getName(), process);
326 |         } catch (IOException e) {
327 |             System.err.println("Could not start process" +  e.getMessage());
328 |         }
329 |     }
330 | 
331 |     private static void autoDeployServer(ConcurrentMap<String, Object> env) throws Exception {
332 |         Server server1 = new Server();
333 | 
334 |         ServerConnector connector = new ServerConnector(server1);
335 |         connector.setPort(PORT);
336 | 
337 |         LatencyRecordingChannelListener listener = new LatencyRecordingChannelListener();
338 |         connector.addBean(listener);
339 | 
340 |         server1.setConnectors(new Connector[]{connector});
341 | 
342 |         ServletContextHandler context = new ServletContextHandler();
343 |         context.setContextPath("/");
344 | 
345 |         if (mode == Mode.DEPLOY_JAVA) {
346 |             ServletHolder servletHolder = context.addServlet(PlainJavaServlet.class, "/");
347 |             servletHolder.setInitOrder(0);
348 |         } else if (mode == Mode.DEPLOY_DB) {
349 |             ServletHolder servletHolder = context.addServlet(DatabaseServlet.class, "/");
350 |             servletHolder.setInitOrder(0);
351 |         } else {
352 | 
353 |             throw new IllegalStateException("not yet implemented");
354 |         }
355 | 
356 | 
357 |         HandlerList mainHandlers = new HandlerList();
358 |         mainHandlers.addHandler(context);
359 |         mainHandlers.addHandler(new DefaultHandler());
360 | 
361 |         server1.setHandler(mainHandlers);
362 | 
363 |         server1.start();
364 |         env.put(Server.class.getName(), server1);
365 |         env.put(LatencyRecordingChannelListener.class.getName(), listener);
366 |     }
367 | 
368 |     private static void stopServer(Map<String, Object> env) throws Exception {
369 |         if (mode.equals(Mode.MANUAL)) {
370 |             stopPreDeployedServer(env);
371 |         }
372 |         else {
373 |             stopAutoDeployedServer(env);
374 |         }
375 |     }
376 | 
377 |     private static void stopAutoDeployedServer(Map<String, Object> env) throws Exception {
378 |         ((Server) env.get(Server.class.getName())).stop();
379 |     }
380 | 
381 |     private static void stopPreDeployedServer(Map<String, Object> env) {
382 |         Process process = (Process) env.get(Process.class.getName());
383 |         process.destroy();
384 |     }
385 | 
386 |     public static void updatePlot(Path outputFolder) throws IOException {
387 |         Path plot = outputFolder.resolve("plot.html");
388 |         if (Files.exists(plot)) {
389 |             Files.delete(plot);
390 |         }
391 |         Path target = Files.createFile(plot);
392 | 
393 | 
394 |         String extension = ".hlog.hgrm";
395 |         String histosPart = Files.list(outputFolder).filter(f -> f.getFileName().toString().endsWith(extension))
396 |                 .map(p -> {
397 |                     try {
398 |                         return Files.readString(p);
399 |                     } catch (IOException e) {
400 |                         throw new UnsupportedOperationException();
401 |                     }
402 |                 })
403 |                 .collect(Collectors.joining("`,`"));
404 | 
405 | 
406 |         String namesPart = Files.list(outputFolder).filter(f -> f.getFileName().toString().endsWith(extension))
407 |                 .map(p -> {
408 | 
409 |                     final String fileName = p.getFileName().toString();
410 |                     final String machinesXRequests = fileName.substring(16, fileName.length() - extension.length());
411 |                     final String[] xes = machinesXRequests.split("x");
412 | 
413 |                     String finalDescriptions = (Integer.parseInt(xes[0]) * Integer.parseInt(xes[1])) + " RPS";
414 |                     return finalDescriptions;
415 | 
416 |                 })
417 |                 .collect(Collectors.joining("\",\""));
418 | 
419 |         String js = "var histos = [`" + histosPart + "`];\n" +
420 |                 "    var names  = [\"" + namesPart + "\"];\n";
421 | 
422 |         try (InputStream resourceAsStream = PerformanceTest.class.getResourceAsStream("/plot_template.html")) {
423 |             String s = IOUtils.toString(resourceAsStream);
424 |             s = s.replace(" // <<< TODO_CHART_DATA >>>", js);
425 |             Files.writeString(target, s);
426 | 
427 |         } catch (IOException e) {
428 |             e.printStackTrace();
429 |         }
430 | 
431 |     }
432 | 
433 | 
434 |     private static void runProbe(Map<String, Object> env) throws IOException {
435 |         ResponseTimeListener responseTimeListener = new ResponseTimeListener();
436 |         env.put(ResponseTimeListener.class.getName(), responseTimeListener);
437 |         ResponseStatusListener responseStatusListener = new ResponseStatusListener();
438 |         env.put(ResponseStatusListener.class.getName(), responseStatusListener);
439 | 
440 |         LoadGenerator generator = LoadGenerator.builder()
441 |                 .scheme("http")
442 |                 .host(SERVER_IP)
443 |                 .port(PORT)
444 |                 .runFor(WARMUP_DURATION.plus(RUN_DURATION).toSeconds(), TimeUnit.SECONDS)
445 |                 .threads(1)
446 |                 .rateRampUpPeriod(WARMUP_DURATION.toSeconds() / 2)
447 |                 .resourceRate(RPS_PROBE)
448 |                 .resource(REQUEST_URI)
449 |                 .resourceListener(responseTimeListener)
450 |                 .listener(responseTimeListener)
451 |                 .resourceListener(responseStatusListener)
452 |                 .listener(responseStatusListener)
453 |                 .build();
454 | 
455 |         CompletableFuture<Void> cf = generator.begin();
456 |         env.put(CompletableFuture.class.getName(), cf);
457 | 
458 |         cf = cf.whenComplete((x, f) -> {
459 |             if (f == null) {
460 |                 LOGGER.info("probe generation complete");
461 |             } else {
462 |                 LOGGER.info("probe generation failure " + f);
463 |             }
464 |         });
465 | 
466 |         env.put(CompletableFuture.class.getName(), cf);
467 |         env.put(LoadGenerator.Config.class.getName(), generator.getConfig());
468 |     }
469 | 
470 |         /*// Start the load generation.
471 |     }*/
472 | 
473 |     private static void runLoadGenerator(Map<String, Object> env) throws IOException {
474 |         ResponseTimeListener responseTimeListener = new ResponseTimeListener();
475 |         env.put(ResponseTimeListener.class.getName(), responseTimeListener);
476 |         ResponseStatusListener responseStatusListener = new ResponseStatusListener();
477 |         env.put(ResponseStatusListener.class.getName(), responseStatusListener);
478 | 
479 |         LoadGenerator generator = LoadGenerator.builder()
480 |                 .scheme("http")
481 |                 .host(SERVER_IP)
482 |                 .port(PORT)
483 |                 .runFor(WARMUP_DURATION.plus(RUN_DURATION).toSeconds(), TimeUnit.SECONDS)
484 |                 .threads(2)
485 |                 .rateRampUpPeriod(WARMUP_DURATION.toSeconds() / 2)
486 |                 .resourceRate(RPS_LOADER)
487 |                 .resource(REQUEST_URI)
488 |                 .resourceListener(responseTimeListener)
489 |                 .listener(responseTimeListener)
490 |                 .resourceListener(responseStatusListener)
491 |                 .listener(responseStatusListener)
492 |                 .build();
493 | 
494 | 
495 |         CompletableFuture<Void> cf = generator.begin();
496 |         // complete.get(); //make sure the load generation is complete
497 | 
498 |         cf = cf.whenComplete((x, f) -> {
499 |             if (f == null) {
500 |                 LOGGER.info("load generation complete");
501 |             } else {
502 |                 LOGGER.info("load generation failure " + f);
503 |             }
504 |         });
505 | 
506 |         env.put(CompletableFuture.class.getName(), cf);
507 |         env.put(LoadGenerator.Config.class.getName(), generator.getConfig());
508 |     }
509 | 
510 | 
511 |     public static void createHgrmHistogram(File hlogFile, OutputStream out) throws FileNotFoundException {
512 |         try (HistogramLogReader reader = new HistogramLogReader(hlogFile)) {
513 |             Histogram total = new Histogram(3);
514 |             while (reader.hasNext()) {
515 |                 Histogram histogram = (Histogram) reader.nextIntervalHistogram();
516 |                 total.add(histogram);
517 |             }
518 |             PrintStream ps = new PrintStream(out);
519 |             total.outputPercentileDistribution(ps, 1000000.00); // scale by 1000000.00 to report in milliseconds
520 |             ps.flush();
521 |         }
522 |     }
523 | 
524 | 
525 |     public static boolean assertThroughput(Path reportRootPath, NodeArrayConfiguration nodeArray, long expectedValue, double errorMargin) throws FileNotFoundException
526 |     {
527 |         long totalCount = 0L;
528 |         for (Node node : nodeArray.nodes())
529 |         {
530 |             Path perfHlog = reportRootPath.resolve(node.getId()).resolve("perf.hlog");
531 |             try (HistogramLogReader histogramLogReader = new HistogramLogReader(perfHlog.toFile()))
532 |             {
533 |                 while (true)
534 |                 {
535 |                     AbstractHistogram histogram = (AbstractHistogram)histogramLogReader.nextIntervalHistogram();
536 |                     if (histogram == null)
537 |                         break;
538 | 
539 |                     totalCount += histogram.getTotalCount();
540 |                 }
541 |             }
542 |         }
543 | 
544 |         System.out.println("  " + nodeArray.id() + " throughput is " + totalCount + " vs expected " + expectedValue);
545 |         double error = expectedValue * errorMargin / 100.0;
546 |         double highBound = expectedValue + error;
547 |         double lowBound = expectedValue - error;
548 |         if (totalCount >= lowBound && totalCount <= highBound)
549 |         {
550 |             System.out.println("  OK; value within " + errorMargin + "% error margin");
551 |             return true;
552 |         }
553 |         else
554 |         {
555 |             System.out.println("  NOK; value out of " + errorMargin + "% error margin");
556 |             return false;
557 |         }
558 |     }
559 | 
560 | 
561 | 
562 |     private static EnumSet<ConfigurableMonitor.Item> copy(EnumSet<ConfigurableMonitor.Item> base, ConfigurableMonitor.Item... items) {
563 |         EnumSet<ConfigurableMonitor.Item> result = EnumSet.copyOf(base);
564 |         result.addAll(Arrays.asList(items));
565 |         return result;
566 |     }
567 | 
568 | 
569 | }
570 | 


--------------------------------------------------------------------------------
/src/main/java/com/mycompany/app/model/TaxRate.java:
--------------------------------------------------------------------------------
 1 | package com.mycompany.app.model;
 2 | 
 3 | public class TaxRate {
 4 | 
 5 |     private final String name;
 6 |     private final Double rate;
 7 | 
 8 |     public TaxRate(String name, Double rate) {
 9 |         this.name = name;
10 |         this.rate = rate;
11 |     }
12 | 
13 |     public String getName() {
14 |         return name;
15 |     }
16 | 
17 |     public Double getRate() {
18 |         return rate;
19 |     }
20 | 
21 |     @Override
22 |     public String toString() {
23 |         return "{ \"name\":" + name + ", \"rate\" :  " + rate + "}";
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/main/java/com/mycompany/app/servlets/DatabaseServlet.java:
--------------------------------------------------------------------------------
 1 | package com.mycompany.app.servlets;
 2 | 
 3 | import com.mycompany.app.util.MyProperties;
 4 | import com.zaxxer.hikari.HikariConfig;
 5 | import com.zaxxer.hikari.HikariDataSource;
 6 | import jakarta.servlet.http.HttpServlet;
 7 | import jakarta.servlet.http.HttpServletRequest;
 8 | import jakarta.servlet.http.HttpServletResponse;
 9 | 
10 | import java.io.IOException;
11 | import java.sql.Connection;
12 | import java.sql.PreparedStatement;
13 | import java.sql.ResultSet;
14 | import java.sql.SQLException;
15 | 
16 | public class DatabaseServlet extends HttpServlet {
17 | 
18 |     private HikariDataSource ds;
19 | 
20 |     static final String sql = "SELECT JSON_ARRAYAGG(JSON_OBJECT('name', name, 'id', id)) as result from tax_rates";
21 | 
22 |     @Override
23 |     public void init() {
24 |         ds = createConnectionPool();
25 |     }
26 | 
27 |     @Override
28 |     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
29 |         resp.setContentType("application/json");
30 | 
31 |         try (Connection connection = ds.getConnection();
32 |              PreparedStatement statement = connection.prepareStatement(sql)) {
33 |             ResultSet resultSet = statement.executeQuery();
34 | 
35 |             while (resultSet.next()) {
36 |                 resultSet.getBinaryStream("result")
37 |                         .transferTo(resp.getOutputStream());
38 |             }
39 | 
40 |         } catch (SQLException e) {
41 |             e.printStackTrace();
42 |         }
43 |     }
44 | 
45 | 
46 |     private HikariDataSource createConnectionPool() {
47 |         HikariConfig config = new HikariConfig();
48 |         final String hikariSize_ = MyProperties.INSTANCE.getProperty("hikari.size");
49 |         if (hikariSize_ != null) {
50 |             final Integer hikariSize = Integer.valueOf(hikariSize_);
51 | 
52 |             System.out.println("Setting HikariCP to " + hikariSize + " connections");
53 |             config.setMinimumIdle(hikariSize);
54 |             config.setMaximumPoolSize(hikariSize);
55 |         }
56 |         config.setJdbcUrl(MyProperties.INSTANCE.getProperty("jdbc.url"));
57 |         config.setUsername(MyProperties.INSTANCE.getProperty("jdbc.user"));
58 |         config.setPassword(MyProperties.INSTANCE.getProperty("jdbc.password"));
59 |         config.addDataSourceProperty("cachePrepStmts", "true");
60 |         config.addDataSourceProperty("prepStmtCacheSize", "250");
61 |         config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
62 |         config.addDataSourceProperty("useServerPrepStmts","true");
63 |         config.addDataSourceProperty("useLocalSessionState","true");
64 |         config.addDataSourceProperty("rewriteBatchedStatements","true");
65 |         config.addDataSourceProperty("cacheResultSetMetadata","true");
66 |         config.addDataSourceProperty("cacheServerConfiguration","true");
67 |         config.addDataSourceProperty("elideSetAutoCommits","true");
68 |         config.addDataSourceProperty("maintainTimeStats", "false");
69 |         
70 |         return new HikariDataSource(config);
71 |     }
72 | 
73 | }


--------------------------------------------------------------------------------
/src/main/java/com/mycompany/app/servlets/PlainJavaServlet.java:
--------------------------------------------------------------------------------
 1 | package com.mycompany.app.servlets;
 2 | 
 3 | import com.mycompany.app.model.TaxRate;
 4 | import jakarta.servlet.http.HttpServlet;
 5 | import jakarta.servlet.http.HttpServletRequest;
 6 | import jakarta.servlet.http.HttpServletResponse;
 7 | 
 8 | import java.io.IOException;
 9 | import java.security.SecureRandom;
10 | 
11 | 
12 | public class PlainJavaServlet extends HttpServlet {
13 | 
14 |     SecureRandom random = new SecureRandom();
15 | 
16 |     @Override
17 |     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
18 |         final TaxRate rate = new TaxRate("German VAT", random.nextDouble());
19 | 
20 |         resp.setContentType("application/json");
21 |         resp.getWriter().write(rate.toString());
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/main/java/com/mycompany/app/util/MyProperties.java:
--------------------------------------------------------------------------------
 1 | package com.mycompany.app.util;
 2 | 
 3 | import com.mycompany.app.PerformanceTest;
 4 | 
 5 | import java.io.IOException;
 6 | import java.io.InputStream;
 7 | import java.nio.file.Files;
 8 | import java.nio.file.Path;
 9 | import java.nio.file.Paths;
10 | import java.util.Properties;
11 | 
12 | public enum MyProperties {
13 | 
14 |     INSTANCE;
15 | 
16 |     private Properties properties = new Properties();
17 | 
18 |     MyProperties() {
19 |         final Path propsFile = Paths.get("./application.properties");
20 |         System.out.println("Curren Directory = " + Paths.get(".").normalize().toAbsolutePath().toString());
21 | 
22 |         if (Files.exists(propsFile)) {
23 |             try (InputStream is = Files.newInputStream(propsFile)) {
24 |                 properties.load(is);
25 |             } catch (IOException e) {
26 |                 e.printStackTrace();
27 |             }
28 |         } else {
29 |             try (InputStream is = PerformanceTest.class.getResourceAsStream("/application.properties")) {
30 |                 properties.load(is);
31 |             } catch (IOException e) {
32 |                 e.printStackTrace();
33 |             }
34 |         }
35 |     }
36 | 
37 |     public Properties getProperties() {
38 |         return properties;
39 |     }
40 | 
41 |     public String getProperty(String key) {
42 |         return (String) properties.get(key);
43 |     }
44 | }


--------------------------------------------------------------------------------
/src/main/java/com/mycompany/app/util/UpdatePlot.java:
--------------------------------------------------------------------------------
 1 | package com.mycompany.app.util;
 2 | 
 3 | import com.mycompany.app.PerformanceTest;
 4 | 
 5 | import java.io.IOException;
 6 | import java.nio.file.Paths;
 7 | 
 8 | public class UpdatePlot {
 9 |     public static void main(String[] args) throws IOException {
10 |         PerformanceTest.updatePlot(Paths.get(".\\target\\results\\plot"));
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/src/main/resources/application.properties:
--------------------------------------------------------------------------------
1 | jdbc.url=jdbc:mysql://yourRdsURL/marco
2 | jdbc.user=chooseYourOwn
3 | jdbc.password=chooseYourOwn
4 | hikari.size = 50


--------------------------------------------------------------------------------
/src/main/resources/database.sql:
--------------------------------------------------------------------------------
1 | create table tax_rates (id int auto_increment primary key not null, name varchar(255));
2 | insert into tax_rates (name) values ('DE VAT');
3 | insert into tax_rates (name) values ('UK VAT');
4 | insert into tax_rates (name) values ('FR VAT');


--------------------------------------------------------------------------------
/src/main/resources/plot_template.html:
--------------------------------------------------------------------------------
  1 | <html>
  2 | <head>
  3 |     <meta charset="UTF-8">
  4 |     <style type="text/css">
  5 |         div.histo {
  6 |             visibility: hidden
  7 |         }
  8 |     </style>
  9 | 
 10 |     <!--Load the AJAX API-->
 11 |     <script type="text/javascript" src="https://www.google.com/jsapi"></script>
 12 | 
 13 |     <script type="text/javascript">
 14 | 
 15 |         if (window.File && window.FileReader && window.FileList && window.Blob) {
 16 |             // Great success! All the File APIs are supported.
 17 |         } else {
 18 |             alert('The File APIs are not fully supported in this browser.');
 19 |         }
 20 | 
 21 |         // Load the Visualization API and the corechart package.
 22 |         google.load('visualization', '1.0', {'packages':['corechart']});
 23 | 
 24 |         // Set a callback to run when the Google Visualization API is loaded.
 25 |         google.setOnLoadCallback(drawInitialChart);
 26 | 
 27 |         var chartData = null;
 28 |         var chart = null;
 29 | 
 30 |         function setChartData(names, histos) {
 31 |             while (names.length < histos.length) {
 32 |                 names.push('Unknown');
 33 |             }
 34 | 
 35 |             var series = [];
 36 |             for (var i = 0; i < histos.length; i++) {
 37 |                 series = appendDataSeries(histos[i], names[i], series);
 38 |             }
 39 | 
 40 |             chartData = google.visualization.arrayToDataTable(series);
 41 |         }
 42 | 
 43 | 
 44 |         function drawInitialChart() {
 45 |             // Connect the choose files button:
 46 |             document.getElementById('files').addEventListener('change', handleFileSelect, false);
 47 | 
 48 |             // <<< TODO_CHART_DATA >>>
 49 | 
 50 |             setChartData(names, histos);
 51 |             drawChart();
 52 |         }
 53 | 
 54 |         var maxPercentile = 1000000;
 55 | 
 56 |         function drawChart() {
 57 | 
 58 |             var ticks =
 59 |                 [{v:1,f:'0%'},
 60 |                     {v:10,f:'90%'},
 61 |                     {v:100,f:'99%'},
 62 |                     {v:1000,f:'99.9%'}/*,
 63 |                     {v:10000,f:'99.99%'},
 64 |                     {v:100000,f:'99.999%'},
 65 |                     {v:1000000,f:'99.9999%'},
 66 |                     {v:10000000,f:'99.99999%'},
 67 |                     {v:100000000,f:'99.999999%'}*/];
 68 | 
 69 |             var unitSelection = document.getElementById("timeUnitSelection");
 70 |             var unitSelIndex = unitSelection.selectedIndex;
 71 |             var unitText = unitSelection.options[unitSelIndex].innerHTML;
 72 | 
 73 |             var options = {
 74 |                 title: 'Latency by Percentile Distribution',
 75 |                 height: 480,
 76 | //            hAxis: {title: 'Percentile', minValue: 0, logScale: true, ticks:ticks },
 77 |                 hAxis: {
 78 |                     title: "Percentile",
 79 |                     minValue: 1, logScale: true, ticks:ticks,
 80 |                     viewWindowMode:'explicit',
 81 |                     viewWindow:{
 82 |                         max:maxPercentile,
 83 |                         min:1
 84 |                     }
 85 |                 },
 86 |                 vAxis: {title: 'Latency (' + unitText + ')', minValue: 0 },
 87 |                 legend: {position: 'bottom'}
 88 |             };
 89 | 
 90 | 
 91 |             // add tooltips with correct percentile text to data:
 92 |             var columns = [0];
 93 |             for (var i = 1; i < chartData.getNumberOfColumns(); i++) {
 94 |                 columns.push(i);
 95 |                 columns.push({
 96 |                     type: 'string',
 97 |                     properties: {
 98 |                         role: 'tooltip'
 99 |                     },
100 |                     calc: (function (j) {
101 |                         return function (dt, row) {
102 |                             var percentile = 100.0 - (100.0/dt.getValue(row, 0));
103 |                             return dt.getColumnLabel(j) + ': ' +
104 |                                 percentile.toPrecision(7) +
105 |                                 '\%\'ile = ' + dt.getValue(row, j) + ' ' + unitText
106 |                         }
107 |                     })(i)
108 |                 });
109 |             }
110 |             var view = new google.visualization.DataView(chartData);
111 |             view.setColumns(columns);
112 | 
113 |             chart = new google.visualization.LineChart(document.getElementById('chart_div'));
114 |             chart.draw(view, options);
115 | 
116 |             google.visualization.events.addListener(chart, 'ready', function () {
117 |                 chart_div.innerHTML = '<img src="' + chart.getImageURI() + '">';
118 |             });
119 | 
120 |         }
121 |     </script>
122 |     <script type="text/javascript">
123 |         function appendDataSeries(histo, name, dataSeries) {
124 |             var series;
125 |             var seriesCount;
126 |             if (dataSeries.length == 0) {
127 |                 series = [ ['X', name] ];
128 |                 seriesCount = 1;
129 |             } else {
130 |                 series = dataSeries;
131 |                 series[0].push(name);
132 |                 seriesCount = series[0].length - 1;
133 |             }
134 | 
135 |             var lines = histo.split("\n");
136 | 
137 |             var seriesIndex = 1;
138 |             for (var i = 0; i < lines.length; i++) {
139 |                 var line = lines[i].trim();
140 |                 var values = line.trim().split(/[ ]+/);
141 | 
142 |                 if (line[0] != '#' && values.length == 4) {
143 | 
144 |                     var y = parseFloat(values[0]);
145 |                     var x = parseFloat(values[3]);
146 | 
147 |                     if (!isNaN(x) && !isNaN(y)) {
148 | 
149 |                         if (seriesIndex >= series.length) {
150 |                             series.push([x]);
151 |                         }
152 | 
153 |                         while (series[seriesIndex].length < seriesCount) {
154 |                             series[seriesIndex].push(null);
155 |                         }
156 | 
157 |                         series[seriesIndex].push(y);
158 |                         seriesIndex++;
159 |                     }
160 |                 }
161 |             }
162 | 
163 |             while (seriesIndex < series.length) {
164 |                 series[seriesIndex].push(null);
165 |                 seriesIndex++;
166 |             }
167 | 
168 |             return series;
169 |         }
170 |     </script>
171 |     <script>
172 |         function timeUnitsSelected(evt) {
173 |             drawChart();
174 |             return {typed: ''};
175 |         }
176 | 
177 |         function doExport(event) {
178 |             saveSvgAsPng(document.querySelector('svg'), 'Histogram', 2.0);
179 |             return {typed: ''};
180 |         }
181 |     </script>
182 | 
183 |     <script>
184 |         function handleFileSelect(evt) {
185 |             var files = evt.target.files; // FileList object
186 |             var fileDisplayArea = document.getElementById('fileDisplayArea');
187 | 
188 |             var names = [];
189 |             var histos = [];
190 | 
191 |             fileDisplayArea.innerText = "file selected...\n";
192 | 
193 |             // Loop through the FileList and render image files as thumbnails.
194 |             for (var i = 0, f; f = files[i]; i++) {
195 |                 var reader = new FileReader();
196 | 
197 |                 reader.onload = (function(theFile) {
198 |                     return function(e) {
199 |                         histos.push(e.target.result);
200 |                         names.push(escape(theFile.name));
201 |                         fileDisplayArea.innerText = " Plotting input from: " + names + "\n";
202 |                         setChartData(names, histos);
203 |                         drawChart();
204 |                     };
205 |                 })(f);
206 | 
207 |                 // Read in the image file as a data URL.
208 |                 reader.readAsText(f);
209 |             }
210 | 
211 |         }
212 | 
213 |     </script>
214 | 
215 |     <script type="text/javascript">
216 |         (function() {
217 |             var out$ = typeof exports != 'undefined' && exports || this;
218 | 
219 |             var doctype = '<?xml version="1.0" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">';
220 | 
221 |             function inlineImages(callback) {
222 |                 var images = document.querySelectorAll('svg image');
223 |                 var left = images.length;
224 |                 if (left == 0) {
225 |                     callback();
226 |                 }
227 |                 for (var i = 0; i < images.length; i++) {
228 |                     (function(image) {
229 |                         if (image.getAttribute('xlink:href')) {
230 |                             var href = image.getAttribute('xlink:href').value;
231 |                             if (/^http/.test(href) && !(new RegExp('^' + window.location.host).test(href))) {
232 |                                 throw new Error("Cannot render embedded images linking to external hosts.");
233 |                             }
234 |                         }
235 |                         var canvas = document.createElement('canvas');
236 |                         var ctx = canvas.getContext('2d');
237 |                         var img = new Image();
238 |                         img.src = image.getAttribute('xlink:href');
239 |                         img.onload = function() {
240 |                             canvas.width = img.width;
241 |                             canvas.height = img.height;
242 |                             ctx.drawImage(img, 0, 0);
243 |                             image.setAttribute('xlink:href', canvas.toDataURL('image/png'));
244 |                             left--;
245 |                             if (left == 0) {
246 |                                 callback();
247 |                             }
248 |                         }
249 |                     })(images[i]);
250 |                 }
251 |             }
252 | 
253 |             function styles(dom) {
254 |                 var css = "";
255 |                 var sheets = document.styleSheets;
256 |                 for (var i = 0; i < sheets.length; i++) {
257 |                     if (sheets[i].hasOwnProperty('cssRules')) {
258 |                         var rules = sheets[i].cssRules;
259 |                         for (var j = 0; j < rules.length; j++) {
260 |                             var rule = rules[j];
261 |                             if (typeof(rule.style) != "undefined") {
262 |                                 css += rule.selectorText + " { " + rule.style.cssText + " }\n";
263 |                             }
264 |                         }
265 |                     }
266 |                 }
267 | 
268 |                 var s = document.createElement('style');
269 |                 s.setAttribute('type', 'text/css');
270 |                 s.innerHTML = "<![CDATA[\n" + css + "\n]]>";
271 | 
272 |                 var defs = document.createElement('defs');
273 |                 defs.appendChild(s);
274 |                 return defs;
275 |             }
276 | 
277 |             out$.svgAsDataUri = function(el, scaleFactor, cb) {
278 |                 scaleFactor = scaleFactor || 1;
279 | 
280 |                 inlineImages(function() {
281 |                     var outer = document.createElement("div");
282 |                     var clone = el.cloneNode(true);
283 |                     var width = parseInt(
284 |                         clone.getAttribute('width')
285 |                         || clone.style.width
286 |                         || out$.getComputedStyle(el).getPropertyValue('width')
287 |                     );
288 |                     var height = parseInt(
289 |                         clone.getAttribute('height')
290 |                         || clone.style.height
291 |                         || out$.getComputedStyle(el).getPropertyValue('height')
292 |                     );
293 | 
294 |                     var xmlns = "http://www.w3.org/2000/xmlns/";
295 | 
296 |                     clone.setAttribute("version", "1.1");
297 |                     clone.setAttributeNS(xmlns, "xmlns", "http://www.w3.org/2000/svg");
298 |                     clone.setAttributeNS(xmlns, "xmlns:xlink", "http://www.w3.org/1999/xlink");
299 |                     clone.setAttribute("width", width * scaleFactor);
300 |                     clone.setAttribute("height", height * scaleFactor);
301 |                     clone.setAttribute("viewBox", "0 0 " + width + " " + height);
302 |                     outer.appendChild(clone);
303 | 
304 |                     clone.insertBefore(styles(clone), clone.firstChild);
305 | 
306 |                     var svg = doctype + outer.innerHTML;
307 |                     var uri = 'data:image/svg+xml;base64,' + window.btoa(unescape(encodeURIComponent(svg)));
308 |                     if (cb) {
309 |                         cb(uri);
310 |                     }
311 |                 });
312 |             }
313 | 
314 |             out$.saveSvgAsPng = function(el, name, scaleFactor) {
315 |                 out$.svgAsDataUri(el, scaleFactor, function(uri) {
316 |                     var image = new Image();
317 |                     image.src = uri;
318 |                     image.onload = function() {
319 |                         var canvas = document.createElement('canvas');
320 |                         canvas.width = image.width;
321 |                         canvas.height = image.height;
322 |                         var context = canvas.getContext('2d');
323 |                         context.drawImage(image, 0, 0);
324 | 
325 |                         var a = document.createElement('a');
326 |                         a.download = name;
327 |                         a.href = canvas.toDataURL('image/png');
328 |                         document.body.appendChild(a);
329 |                         a.click();
330 |                     }
331 |                 });
332 |             }
333 |         })();
334 |     </script>
335 | 
336 |     <style>
337 |         .slider-width500
338 |         {
339 |             width: 500px;
340 |         }
341 |     </style>
342 | 
343 | </head>
344 | 
345 | <body>
346 | <h2>HdrHistogram Plotter</h2>
347 | 
348 | <input type="file" id="files" name="files[]" multiple />
349 | 
350 | <pre id="fileDisplayArea">Please select file(s) above.</pre>
351 | 
352 | <!--Div that will hold the chart-->
353 | <div id="chart_div">None Loaded</div>
354 | 
355 | Latency time units:
356 | <select name="units" size="1" id="timeUnitSelection" onChange="timeUnitsSelected()">
357 |     <option value="Latency (seconds)">seconds</option>
358 |     <option value="Latency (milliseconds)">milliseconds</option>
359 |     <option selected value="Latency (µs)">microseconds</option>
360 |     <option value="Latency (nanoseconds)">nanoseconds</option>
361 | </select>
362 | <button type='button' onclick='doExport(event)'>Export Image</button>
363 | 
364 | &nbsp; &nbsp; &nbsp; &nbsp;
365 | <p>
366 |     Percentile range:
367 | 
368 |     <input type="range" class="slider-width500"
369 |            min="1" max="8" value="7" step="1"
370 |            width="300px"
371 |            onchange="showValue(this.value)" />
372 |     <span id="percentileRange">99.99999%</span>
373 |     <script type="text/javascript">
374 |         function showValue(newValue) {
375 |             var x = Math.pow(10, newValue);
376 |             var percentile = 100.0 - (100.0 / x);
377 |             document.getElementById("percentileRange").innerHTML=percentile + "%";
378 |             maxPercentile = x;
379 |             drawChart();
380 |             return {typed: ''};
381 |         }
382 |     </script>
383 | </p>
384 | <p>
385 |     <br>
386 |     *** Note: Input files are expected to be in the .hgrm format produced by
387 |     HistogramLogProcessor, or the percentile output format for HdrHistogram.
388 |     See example file format
389 |     <a href="https://github.com/HdrHistogram/HdrHistogram/blob/master/GoogleChartsExample/example1.txt">here</a>
390 | </p>
391 | <!--<h4>Expected Service Level:</h4>-->
392 | <!--<input type="checkbox" name="ESL" value="ESL">Plot Expected Service Level<br>-->
393 | <!--Percentile:-->
394 | <!--<input type="text" id="ESLPercentile0" name="ESLPercentile0" size="6" value = 90 />-->
395 | <!--% &nbsp &nbsp &nbsp Limit:-->
396 | <!--<input type="text" id="ESLLimit0" name="ESLLimit0" size="12"/>-->
397 | <!--<br>-->
398 | <!--Percentile:-->
399 | <!--<input type="text" id="ESLPercentile1" name="ESLPercentile1" size="6" value = 99 />-->
400 | <!--% &nbsp &nbsp &nbsp Limit:-->
401 | <!--<input type="text" id="ESLLimit1" name="ESLLimit1" size="12"/>-->
402 | <!--<br>-->
403 | <!--Percentile:-->
404 | <!--<input type="text" id="ESLPercentile2" name="ESLPercentile2" size="6" value = 99.99 />-->
405 | <!--% &nbsp &nbsp &nbsp Limit:-->
406 | <!--<input type="text" id="ESLLimit2" name="ESLLimit2" size="12"/>-->
407 | <!--<br>-->
408 | <!--Percentile:-->
409 | <!--<input type="text" id="ESLPercentile3" name="ESLPercentile2" size="6" value="100.0" readonly/>-->
410 | <!--% &nbsp &nbsp &nbsp Limit:-->
411 | <!--<input type="text" id="ESLLimit3" name="ESLLimit2" size="12"/>-->
412 | 
413 | <div id="data_1" class="histo">
414 |     Value     Percentile TotalCount 1/(1-Percentile)
415 | 
416 |     2.759 0.000000000000          1           1.00
417 |     2.990 0.100000000000         10           1.11
418 |     3.056 0.200000000000         19           1.25
419 |     3.115 0.300000000000         31           1.43
420 |     3.164 0.400000000000         38           1.67
421 |     3.326 0.500000000000         47           2.00
422 |     3.977 0.550000000000         52           2.22
423 |     6.193 0.600000000000         57           2.50
424 |     21.889 0.650000000000         62           2.86
425 |     36.438 0.700000000000         66           3.33
426 |     68.551 0.750000000000         71           4.00
427 |     84.935 0.775000000000         73           4.44
428 |     102.760 0.800000000000         76           5.00
429 |     111.477 0.825000000000         78           5.71
430 |     122.618 0.850000000000         80           6.67
431 |     199.623 0.875000000000         83           8.00
432 |     200.802 0.887500000000         84           8.89
433 |     222.953 0.900000000000         85          10.00
434 |     258.474 0.912500000000         86          11.43
435 |     340.787 0.925000000000         87          13.33
436 |     410.518 0.937500000000         89          16.00
437 |     410.518 0.943750000000         89          17.78
438 |     433.324 0.950000000000         90          20.00
439 |     433.324 0.956250000000         90          22.86
440 |     448.528 0.962500000000         91          26.67
441 |     483.131 0.968750000000         92          32.00
442 |     483.131 0.971875000000         92          35.56
443 |     483.131 0.975000000000         92          40.00
444 |     483.131 0.978125000000         92          45.71
445 |     620.757 0.981250000000         93          53.33
446 |     620.757 0.984375000000         93          64.00
447 |     620.757 0.985937500000         93          71.11
448 |     620.757 0.987500000000         93          80.00
449 |     620.757 0.989062500000         93          91.43
450 |     904.397 0.990625000000         94         106.67
451 |     904.397 1.000000000000         94
452 |     #[Mean    =       72.069, StdDeviation   =      150.578]
453 |     #[Max     =      904.397, Total count    =           94]
454 |     #[Buckets =           17, SubBuckets     =         2048]
455 | </div>
456 | <div id='data_2' class='histo'>
457 |     Value     Percentile TotalCount 1/(1-Percentile)
458 | 
459 | 
460 |     2.626 0.000000000000          1           1.00
461 |     2.689 0.100000000000          9           1.11
462 |     2.730 0.200000000000         18           1.25
463 |     2.753 0.300000000000         27           1.43
464 |     2.777 0.400000000000         36           1.67
465 |     2.804 0.500000000000         45           2.00
466 |     2.828 0.550000000000         49           2.22
467 |     2.845 0.600000000000         56           2.50
468 |     2.851 0.650000000000         60           2.86
469 |     2.879 0.700000000000         63           3.33
470 |     2.888 0.750000000000         67           4.00
471 |     2.894 0.775000000000         69           4.44
472 |     2.916 0.800000000000         72           5.00
473 |     2.970 0.825000000000         74           5.71
474 |     2.974 0.850000000000         77           6.67
475 |     2.984 0.875000000000         78           8.00
476 |     2.986 0.887500000000         79           8.89
477 |     3.006 0.900000000000         81          10.00
478 |     3.015 0.912500000000         82          11.43
479 |     3.017 0.925000000000         83          13.33
480 |     3.025 0.937500000000         84          16.00
481 |     3.025 0.943750000000         84          17.78
482 |     3.129 0.950000000000         85          20.00
483 |     3.164 0.956250000000         86          22.86
484 |     3.164 0.962500000000         86          26.67
485 |     3.250 0.968750000000         87          32.00
486 |     3.250 0.971875000000         87          35.56
487 |     3.250 0.975000000000         87          40.00
488 |     6.316 0.978125000000         88          45.71
489 |     6.316 0.981250000000         88          53.33
490 |     6.316 0.984375000000         88          64.00
491 |     6.316 0.985937500000         88          71.11
492 |     6.316 0.987500000000         88          80.00
493 |     98.304 0.989062500000         89          91.43
494 |     98.304 1.000000000000         89
495 |     #[Mean    =        3.936, StdDeviation   =       10.064]
496 |     #[Max     =       98.304, Total count    =           89]
497 |     #[Buckets =           17, SubBuckets     =         2048]
498 | </div>
499 | <div id='data_3' class='histo'>
500 |     Value     Percentile TotalCount 1/(1-Percentile)
501 |     2.791 0.000000000000          1           1.00
502 |     2.810 0.100000000000          3           1.11
503 |     2.845 0.200000000000          6           1.25
504 |     2.867 0.300000000000          9           1.43
505 |     2.929 0.400000000000         12           1.67
506 |     2.951 0.500000000000         15           2.00
507 |     2.953 0.550000000000         16           2.22
508 |     2.968 0.600000000000         18           2.50
509 |     2.970 0.650000000000         19           2.86
510 |     3.013 0.700000000000         22           3.33
511 |     3.013 0.750000000000         22           4.00
512 |     3.029 0.775000000000         23           4.44
513 |     3.033 0.800000000000         24           5.00
514 |     3.033 0.825000000000         24           5.71
515 |     3.135 0.850000000000         25           6.67
516 |     3.176 0.875000000000         26           8.00
517 |     3.176 0.887500000000         26           8.89
518 |     3.242 0.900000000000         27          10.00
519 |     3.242 0.912500000000         27          11.43
520 |     3.242 0.925000000000         27          13.33
521 |     5.317 0.937500000000         28          16.00
522 |     5.317 0.943750000000         28          17.78
523 |     5.317 0.950000000000         28          20.00
524 |     5.317 0.956250000000         28          22.86
525 |     5.317 0.962500000000         28          26.67
526 |     90.309 0.968750000000         29          32.00
527 |     90.309 1.000000000000         29
528 |     #[Mean    =        6.037, StdDeviation   =       15.926]
529 |     #[Max     =       90.309, Total count    =           29]
530 |     #[Buckets =           17, SubBuckets     =         2048]
531 | </div>
532 | </body>
533 | </html>


--------------------------------------------------------------------------------
/src/main/resources/simplelogger.properties:
--------------------------------------------------------------------------------
1 | org.slf4j.simpleLogger.logFile=System.out
2 | org.slf4j.simpleLogger.log=error
3 | org.slf4j.simpleLogger.log.org.apache=error
4 | org.slf4j.simpleLogger.log.com.mycompany=info


--------------------------------------------------------------------------------