diff --git a/modules/performance-statistics-ext/bin/print-statistics.sh b/modules/performance-statistics-ext/bin/print-statistics.sh
new file mode 100644
index 0000000..4d250a1
--- /dev/null
+++ b/modules/performance-statistics-ext/bin/print-statistics.sh
@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+#
+# The script is used to read performance statistics files to the console or file.
+#
+
+SCRIPT_DIR=$(cd $(dirname "$0"); pwd)
+
+#
+# JVM options. See http://java.sun.com/javase/technologies/hotspot/vmoptions.jsp for more details.
+#
+# ADD YOUR/CHANGE ADDITIONAL OPTIONS HERE
+#
+JVM_OPTS="-Xms32m -Xmx512m"
+
+#
+# Define classpath
+#
+CP="${SCRIPT_DIR}/libs/*"
+
+#
+# Set main class to run the tool.
+#
+MAIN_CLASS=org.apache.ignite.internal.performancestatistics.PerformanceStatisticsPrinter
+
+#
+# Garbage Collection options.
+#
+JVM_OPTS="\
+    -XX:+UseG1GC \
+     ${JVM_OPTS}"
+
+#
+# Run tool.
+#
+java ${JVM_OPTS} -cp "${CP}" ${MAIN_CLASS} $@
diff --git a/modules/performance-statistics-ext/src/main/java/org/apache/ignite/internal/performancestatistics/PerformanceStatisticsPrinter.java b/modules/performance-statistics-ext/src/main/java/org/apache/ignite/internal/performancestatistics/PerformanceStatisticsPrinter.java
new file mode 100644
index 0000000..789bf5b
--- /dev/null
+++ b/modules/performance-statistics-ext/src/main/java/org/apache/ignite/internal/performancestatistics/PerformanceStatisticsPrinter.java
@@ -0,0 +1,216 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.performancestatistics;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.apache.ignite.internal.performancestatistics.handlers.PrintHandler;
+import org.apache.ignite.internal.processors.performancestatistics.FilePerformanceStatisticsReader;
+import org.apache.ignite.internal.processors.performancestatistics.OperationType;
+import org.apache.ignite.internal.util.typedef.internal.A;
+import org.apache.ignite.internal.util.typedef.internal.CU;
+import org.apache.ignite.internal.util.typedef.internal.U;
+import org.jetbrains.annotations.Nullable;
+
+import static java.util.Collections.singletonList;
+import static java.util.stream.Collectors.joining;
+
+/**
+ * Performance statistics printer.
+ */
+public class PerformanceStatisticsPrinter {
+    /**
+     * @param args Program arguments or '-h' to get usage help.
+     */
+    public static void main(String... args) throws Exception {
+        Parameters params = parseArguments(args);
+
+        validateParameters(params);
+
+        PrintStream ps = printStream(params.outFile);
+
+        try {
+            new FilePerformanceStatisticsReader(
+                new PrintHandler(ps, params.ops, params.from, params.to,params.cacheIds))
+                .read(singletonList(new File(params.statFileOrDir)));
+        }
+        finally {
+            if (params.outFile != null)
+                ps.close();
+        }
+    }
+
+    /**
+     * Parses arguments or print help.
+     *
+     * @param args Arguments to parse.
+     * @return Program arguments.
+     */
+    private static Parameters parseArguments(String[] args) {
+        if (args == null || args.length == 0 || "--help".equalsIgnoreCase(args[0]) || "-h".equalsIgnoreCase(args[0]))
+            printHelp();
+
+        Parameters params = new Parameters();
+
+        Iterator<String> iter = Arrays.asList(args).iterator();
+
+        params.statFileOrDir = iter.next();
+
+        while (iter.hasNext()) {
+            String arg = iter.next();
+
+            if ("--out".equalsIgnoreCase(arg)) {
+                A.ensure(iter.hasNext(), "Expected output file name");
+
+                params.outFile = iter.next();
+            }
+            else if ("--ops".equalsIgnoreCase(arg)) {
+                A.ensure(iter.hasNext(), "Expected operation types");
+
+                String[] ops = iter.next().split(",");
+
+                A.ensure(ops.length > 0, "Expected at least one operation");
+
+                params.ops = new BitSet();
+
+                for (String op : ops) {
+                    OperationType opType = enumIgnoreCase(op, OperationType.class);
+
+                    A.ensure(opType != null, "Unknown operation type [op=" + op + ']');
+
+                    params.ops.set(opType.id());
+                }
+            }
+            else if ("--from".equalsIgnoreCase(arg)) {
+                A.ensure(iter.hasNext(), "Expected time from");
+
+                params.from = Long.parseLong(iter.next());
+            }
+            else if ("--to".equalsIgnoreCase(arg)) {
+                A.ensure(iter.hasNext(), "Expected time to");
+
+                params.to = Long.parseLong(iter.next());
+            }
+            else if ("--caches".equalsIgnoreCase(arg)) {
+                A.ensure(iter.hasNext(), "Expected cache names");
+
+                String[] caches = iter.next().split(",");
+
+                A.ensure(caches.length > 0, "Expected at least one cache name");
+
+                params.cacheIds = Arrays.stream(caches).map(CU::cacheId).collect(Collectors.toSet());
+            }
+            else
+                throw new IllegalArgumentException("Unknown command: " + arg);
+        }
+
+        return params;
+    }
+
+    /** Prints help. */
+    private static void printHelp() {
+        String ops = Arrays.stream(OperationType.values()).map(Enum::toString).collect(joining(", "));
+
+        System.out.println("The script is used to print performance statistics files to the console or file." +
+            U.nl() + U.nl() +
+            "Usage: print-statistics.sh path_to_files [--out out_file] [--ops op_types] " +
+            "[--from startTimeFrom] [--to startTimeTo] [--caches cache_names]" + U.nl() +
+            U.nl() +
+            "  path_to_files - Performance statistics file or files directory." + U.nl() +
+            "  out_file      - Output file." + U.nl() +
+            "  op_types      - Comma separated list of operation types to filter the output." + U.nl() +
+            "  from          - The minimum operation start time to filter the output." + U.nl() +
+            "  to            - The maximum operation start time to filter the output." + U.nl() +
+            "  cache_names   - Comma separated list of cache names to filter the output." + U.nl() +
+            U.nl() +
+            "Times must be specified in the Unix time format in milliseconds." + U.nl() +
+            "List of operation types: " + ops + '.');
+
+        System.exit(0);
+    }
+
+    /** @param params Validates parameters. */
+    private static void validateParameters(Parameters params) {
+        File statFileOrDir = new File(params.statFileOrDir);
+
+        A.ensure(statFileOrDir.exists(), "Performance statistics file or files directory does not exists");
+    }
+
+    /** @return Print stream to the console or file. */
+    private static PrintStream printStream(@Nullable String outFile) {
+        PrintStream ps;
+
+        if (outFile != null) {
+            try {
+                ps = new PrintStream(new BufferedOutputStream(new FileOutputStream(new File(outFile), true)));
+            }
+            catch (IOException e) {
+                throw new IllegalArgumentException("Cannot write to output file", e);
+            }
+        }
+        else
+            ps = System.out;
+
+        return ps;
+    }
+
+    /**
+     * Gets the enum for the given name ignore case.
+     *
+     * @param name Enum name.
+     * @param cls Enum class.
+     * @return The enum or {@code null} if not found.
+     */
+    private static <E extends Enum<E>> @Nullable E enumIgnoreCase(String name, Class<E> cls) {
+        for (E e : cls.getEnumConstants()) {
+            if (e.name().equalsIgnoreCase(name))
+                return e;
+        }
+
+        return null;
+    }
+
+    /** Printer parameters. */
+    private static class Parameters {
+        /** Performance statistics file or files directory. */
+        private String statFileOrDir;
+
+        /** Output file. */
+        @Nullable private String outFile;
+
+        /** Operation types to print. */
+        @Nullable private BitSet ops;
+
+        /** The minimum operation start time to filter the output. */
+        private long from = Long.MIN_VALUE;
+
+        /** The maximum operation start time to filter the output. */
+        private long to = Long.MAX_VALUE;
+
+        /** Cache identifiers to filter the output. */
+        @Nullable private Set<Integer> cacheIds;
+    }
+}
diff --git a/modules/performance-statistics-ext/src/main/java/org/apache/ignite/internal/performancestatistics/handlers/PrintHandler.java b/modules/performance-statistics-ext/src/main/java/org/apache/ignite/internal/performancestatistics/handlers/PrintHandler.java
new file mode 100644
index 0000000..df27ae8
--- /dev/null
+++ b/modules/performance-statistics-ext/src/main/java/org/apache/ignite/internal/performancestatistics/handlers/PrintHandler.java
@@ -0,0 +1,256 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.performancestatistics.handlers;
+
+import java.io.PrintStream;
+import java.util.BitSet;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ignite.internal.processors.cache.query.GridCacheQueryType;
+import org.apache.ignite.internal.processors.performancestatistics.OperationType;
+import org.apache.ignite.internal.processors.performancestatistics.PerformanceStatisticsHandler;
+import org.apache.ignite.internal.util.GridIntIterator;
+import org.apache.ignite.internal.util.GridIntList;
+import org.apache.ignite.lang.IgniteUuid;
+import org.jetbrains.annotations.Nullable;
+
+import static org.apache.ignite.internal.performancestatistics.util.Utils.printEscaped;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.CACHE_START;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.JOB;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.QUERY;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.QUERY_READS;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.TASK;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.TX_COMMIT;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.TX_ROLLBACK;
+
+/**
+ * Handler to print performance statistics operations.
+ */
+public class PrintHandler implements PerformanceStatisticsHandler {
+    /** Print stream. */
+    private final PrintStream ps;
+
+    /** Operation types. */
+    @Nullable private final BitSet ops;
+
+    /** Start time from. */
+    private final long from;
+
+    /** Start time to. */
+    private final long to;
+
+    /** Cache identifiers to filter the output. */
+    @Nullable private final Set<Integer> cacheIds;
+
+    /**
+     * @param ps Print stream.
+     * @param ops Set of operations to print.
+     * @param from The minimum operation start time to filter the output.
+     * @param to The maximum operation start time to filter the output.
+     * @param cacheIds Cache identifiers to filter the output.
+     */
+    public PrintHandler(PrintStream ps, @Nullable BitSet ops, long from, long to, @Nullable Set<Integer> cacheIds) {
+        this.ps = ps;
+        this.ops = ops;
+        this.from = from;
+        this.to = to;
+        this.cacheIds = cacheIds;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void cacheStart(UUID nodeId, int cacheId, String name) {
+        if (skip(CACHE_START, cacheId))
+            return;
+
+        ps.print("{\"op\":\"" + CACHE_START);
+        ps.print("\",\"nodeId\":\"");
+        ps.print(nodeId);
+        ps.print("\",\"cacheId\":");
+        ps.print(cacheId);
+        ps.print(",\"name\":\"");
+        printEscaped(ps, name);
+        ps.println("\"}");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void cacheOperation(UUID nodeId, OperationType type, int cacheId, long startTime, long duration) {
+        if (skip(type, startTime, cacheId))
+            return;
+
+        ps.print("{\"op\":\"");
+        ps.print(type);
+        ps.print("\",\"nodeId\":\"");
+        ps.print(nodeId);
+        ps.print("\",\"cacheId\":");
+        ps.print(cacheId);
+        ps.print(",\"startTime\":");
+        ps.print(startTime);
+        ps.print(",\"duration\":");
+        ps.print(duration);
+        ps.println("}");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void transaction(UUID nodeId, GridIntList cacheIds, long startTime, long duration,
+        boolean commited) {
+        OperationType op = commited ? TX_COMMIT : TX_ROLLBACK;
+
+        if (skip(op, startTime, cacheIds))
+            return;
+
+        ps.print("{\"op\":\"");
+        ps.print(op);
+        ps.print("\",\"nodeId\":\"");
+        ps.print(nodeId);
+        ps.print("\",\"cacheIds\":");
+        ps.print(cacheIds);
+        ps.print(",\"startTime\":");
+        ps.print(startTime);
+        ps.print(",\"duration\":");
+        ps.print(duration);
+        ps.println("}");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void query(UUID nodeId, GridCacheQueryType type, String text, long id, long startTime,
+        long duration, boolean success) {
+        if (skip(QUERY, startTime))
+            return;
+
+        ps.print("{\"op\":\"" + QUERY);
+        ps.print("\",\"nodeId\":\"");
+        ps.print(nodeId);
+        ps.print("\",\"type\":\"");
+        ps.print(type);
+        ps.print("\",\"text\":\"");
+        printEscaped(ps, text);
+        ps.print("\",\"id\":");
+        ps.print(id);
+        ps.print(",\"startTime\":");
+        ps.print(startTime);
+        ps.print(",\"duration\":");
+        ps.print(duration);
+        ps.print(",\"success\":");
+        ps.print(success);
+        ps.println("}");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void queryReads(UUID nodeId, GridCacheQueryType type, UUID queryNodeId, long id,
+        long logicalReads, long physicalReads) {
+        if (skip(QUERY_READS))
+            return;
+
+        ps.print("{\"op\":\"" + QUERY_READS);
+        ps.print("\",\"nodeId\":\"");
+        ps.print(nodeId);
+        ps.print("\",\"type\":\"");
+        ps.print(type);
+        ps.print("\",\"queryNodeId\":\"");
+        ps.print(queryNodeId);
+        ps.print("\",\"id\":");
+        ps.print(id);
+        ps.print(",\"logicalReads\":");
+        ps.print(logicalReads);
+        ps.print(",\"physicalReads\":");
+        ps.print(physicalReads);
+        ps.println("}");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void task(UUID nodeId, IgniteUuid sesId, String taskName, long startTime, long duration,
+        int affPartId) {
+        if (skip(TASK, startTime))
+            return;
+
+        ps.print("{\"op\":\"" + TASK);
+        ps.print("\",\"nodeId\":\"");
+        ps.print(nodeId);
+        ps.print("\",\"sesId\":\"");
+        ps.print(sesId);
+        ps.print("\",\"taskName\":\"");
+        printEscaped(ps, taskName);
+        ps.print("\",\"startTime\":");
+        ps.print(startTime);
+        ps.print(",\"duration\":");
+        ps.print(duration);
+        ps.print(",\"affPartId\":");
+        ps.print(affPartId);
+        ps.println("}");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void job(UUID nodeId, IgniteUuid sesId, long queuedTime, long startTime, long duration,
+        boolean timedOut) {
+        if (skip(JOB, startTime))
+            return;
+
+        ps.print("{\"op\":\"" + JOB);
+        ps.print("\",\"nodeId\":\"");
+        ps.print(nodeId);
+        ps.print("\",\"sesId\":\"");
+        ps.print(sesId);
+        ps.print("\",\"queuedTime\":");
+        ps.print(queuedTime);
+        ps.print(",\"startTime\":");
+        ps.print(startTime);
+        ps.print(",\"duration\":");
+        ps.print(duration);
+        ps.print(",\"timedOut\":");
+        ps.print(timedOut);
+        ps.println("}");
+    }
+
+    /** @return {@code True} if the operation should be skipped. */
+    private boolean skip(OperationType op) {
+        return !(ops == null || ops.get(op.id()));
+    }
+
+    /** @return {@code True} if the operation should be skipped. */
+    private boolean skip(OperationType op, long startTime) {
+        return skip(op) || startTime < from || startTime > to;
+    }
+
+    /** @return {@code True} if the operation should be skipped. */
+    private boolean skip(OperationType op, int cacheId) {
+        return skip(op) || !(cacheIds == null || cacheIds.contains(cacheId));
+    }
+
+    /** @return {@code True} if the operation should be skipped. */
+    private boolean skip(OperationType op, long startTime, int cacheId) {
+        return skip(op, startTime) || !(cacheIds == null || cacheIds.contains(cacheId));
+    }
+
+    /** @return {@code True} if the operation should be skipped. */
+    private boolean skip(OperationType op, long startTime, GridIntList cacheIds) {
+        if (skip(op, startTime))
+            return true;
+
+        if (this.cacheIds == null)
+            return false;
+
+        GridIntIterator iter = cacheIds.iterator();
+
+        while (iter.hasNext()) {
+            if (this.cacheIds.contains(iter.next()))
+                return false;
+        }
+
+        return true;
+    }
+}
diff --git a/modules/performance-statistics-ext/src/main/java/org/apache/ignite/internal/performancestatistics/util/Utils.java b/modules/performance-statistics-ext/src/main/java/org/apache/ignite/internal/performancestatistics/util/Utils.java
index 1e7249e..01a0312 100644
--- a/modules/performance-statistics-ext/src/main/java/org/apache/ignite/internal/performancestatistics/util/Utils.java
+++ b/modules/performance-statistics-ext/src/main/java/org/apache/ignite/internal/performancestatistics/util/Utils.java
@@ -17,6 +17,8 @@
 
 package org.apache.ignite.internal.performancestatistics.util;
 
+import java.io.PrintStream;
+import com.fasterxml.jackson.core.io.CharTypes;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
@@ -26,6 +28,9 @@
     /** Json mapper. */
     public static final ObjectMapper MAPPER = new ObjectMapper();
 
+    /** */
+    private final static char[] HC = "0123456789ABCDEF".toCharArray();
+
     /** Creates empty object for given value if absent. */
     public static ObjectNode createObjectIfAbsent(String val, ObjectNode json) {
         ObjectNode node = (ObjectNode)json.get(val);
@@ -51,4 +56,44 @@
 
         return node;
     }
+
+    /**
+     * Prints JSON-escaped string to the stream.
+     *
+     * @param ps Print stream to write to.
+     * @param str String to print.
+     * @see CharTypes#appendQuoted(StringBuilder, String)
+     */
+    public static void printEscaped(PrintStream ps, String str) {
+        int[] escCodes = CharTypes.get7BitOutputEscapes();
+
+        int escLen = escCodes.length;
+
+        for (int i = 0, len = str.length(); i < len; ++i) {
+            char c = str.charAt(i);
+
+            if (c >= escLen || escCodes[c] == 0) {
+                ps.print(c);
+
+                continue;
+            }
+
+            ps.print('\\');
+
+            int escCode = escCodes[c];
+
+            if (escCode < 0) {
+                ps.print('u');
+                ps.print('0');
+                ps.print('0');
+
+                int val = c;
+
+                ps.print(HC[val >> 4]);
+                ps.print(HC[val & 0xF]);
+            }
+            else
+                ps.print((char)escCode);
+        }
+    }
 }
diff --git a/modules/performance-statistics-ext/src/test/java/org/apache/ignite/internal/performancestatistics/IgnitePerformanceStatisticsReportTestSuite.java b/modules/performance-statistics-ext/src/test/java/org/apache/ignite/internal/performancestatistics/IgnitePerformanceStatisticsReportTestSuite.java
index 35265e7..c21ddb2 100644
--- a/modules/performance-statistics-ext/src/test/java/org/apache/ignite/internal/performancestatistics/IgnitePerformanceStatisticsReportTestSuite.java
+++ b/modules/performance-statistics-ext/src/test/java/org/apache/ignite/internal/performancestatistics/IgnitePerformanceStatisticsReportTestSuite.java
@@ -25,7 +25,8 @@
  */
 @RunWith(Suite.class)
 @Suite.SuiteClasses({
-    PerformanceStatisticsReportSelfTest.class
+    PerformanceStatisticsReportSelfTest.class,
+    PerformanceStatisticsPrinterTest.class
 })
 public class IgnitePerformanceStatisticsReportTestSuite {
 }
diff --git a/modules/performance-statistics-ext/src/test/java/org/apache/ignite/internal/performancestatistics/PerformanceStatisticsPrinterTest.java b/modules/performance-statistics-ext/src/test/java/org/apache/ignite/internal/performancestatistics/PerformanceStatisticsPrinterTest.java
new file mode 100644
index 0000000..4cd267f
--- /dev/null
+++ b/modules/performance-statistics-ext/src/test/java/org/apache/ignite/internal/performancestatistics/PerformanceStatisticsPrinterTest.java
@@ -0,0 +1,328 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.performancestatistics;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.function.Consumer;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.ignite.internal.processors.cache.query.GridCacheQueryType;
+import org.apache.ignite.internal.processors.performancestatistics.FilePerformanceStatisticsWriter;
+import org.apache.ignite.internal.processors.performancestatistics.OperationType;
+import org.apache.ignite.internal.util.GridIntList;
+import org.apache.ignite.internal.util.typedef.F;
+import org.apache.ignite.internal.util.typedef.internal.CU;
+import org.apache.ignite.internal.util.typedef.internal.U;
+import org.apache.ignite.lang.IgniteUuid;
+import org.apache.ignite.logger.java.JavaLogger;
+import org.apache.ignite.testframework.junits.GridTestKernalContext;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import static java.util.stream.Collectors.joining;
+import static org.apache.ignite.internal.processors.performancestatistics.FilePerformanceStatisticsWriter.PERF_STAT_DIR;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.CACHE_GET;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.CACHE_PUT;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.CACHE_START;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.JOB;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.QUERY;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.QUERY_READS;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.TASK;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.TX_COMMIT;
+import static org.apache.ignite.internal.processors.performancestatistics.OperationType.TX_ROLLBACK;
+import static org.apache.ignite.testframework.GridTestUtils.waitForCondition;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * Tests the performance statistics printer.
+ */
+public class PerformanceStatisticsPrinterTest {
+    /** Test node ID. */
+    private final static UUID NODE_ID = UUID.randomUUID();
+
+    /** */
+    @Before
+    public void beforeTest() throws Exception {
+        U.delete(new File(U.defaultWorkDirectory()));
+    }
+
+    /** */
+    @After
+    public void afterTest() throws Exception {
+        U.delete(new File(U.defaultWorkDirectory()));
+    }
+
+    /** @throws Exception If failed. */
+    @Test
+    public void testOperationsFilter() throws Exception {
+        createStatistics(writer -> {
+            writer.cacheStart(0, "cache");
+            writer.cacheOperation(CACHE_GET, 0, 0, 0);
+            writer.transaction(GridIntList.asList(0), 0, 0, true);
+            writer.transaction(GridIntList.asList(0), 0, 0, false);
+            writer.query(GridCacheQueryType.SQL_FIELDS, "query", 0, 0, 0, true);
+            writer.queryReads(GridCacheQueryType.SQL_FIELDS, NODE_ID, 0, 0, 0);
+            writer.task(new IgniteUuid(NODE_ID, 0), "task", 0, 0, 0);
+            writer.job(new IgniteUuid(NODE_ID, 0), 0, 0, 0, true);
+        });
+
+        List<OperationType> expOps = F.asList(CACHE_START, CACHE_GET, TX_COMMIT, TX_ROLLBACK, QUERY, QUERY_READS,
+            TASK, JOB);
+
+        checkOperationFilter(null, expOps);
+        checkOperationFilter(F.asList(CACHE_START), F.asList(CACHE_START));
+        checkOperationFilter(F.asList(TASK, JOB), F.asList(TASK, JOB));
+        checkOperationFilter(F.asList(CACHE_PUT), Collections.emptyList());
+    }
+
+    /** */
+    private void checkOperationFilter(List<OperationType> opsArg, List<OperationType> expOps) throws Exception {
+        List<String> args = new LinkedList<>();
+
+        if (opsArg != null) {
+            args.add("--ops");
+
+            args.add(opsArg.stream().map(Enum::toString).collect(joining(",")));
+        }
+
+        List<OperationType> ops = new LinkedList<>(expOps);
+
+        readStatistics(args, json -> {
+            OperationType op = OperationType.valueOf(json.get("op").asText());
+
+            assertTrue("Unexpected operation: " + op, ops.remove(op));
+
+            UUID nodeId = UUID.fromString(json.get("nodeId").asText());
+
+            assertEquals(NODE_ID, nodeId);
+        });
+
+        assertTrue("Expected operations:" + ops, ops.isEmpty());
+    }
+
+    /** @throws Exception If failed. */
+    @Test
+    public void testStartTimeFilter() throws Exception {
+        long startTime1 = 10;
+        long startTime2 = 20;
+
+        createStatistics(writer -> {
+            for (long startTime : new long[] {startTime1, startTime2}) {
+                writer.cacheOperation(CACHE_GET, 0, startTime, 0);
+                writer.transaction(GridIntList.asList(0), startTime, 0, true);
+                writer.transaction(GridIntList.asList(0), startTime, 0, false);
+                writer.query(GridCacheQueryType.SQL_FIELDS, "query", 0, startTime, 0, true);
+                writer.task(new IgniteUuid(NODE_ID, 0), "", startTime, 0, 0);
+                writer.job(new IgniteUuid(NODE_ID, 0), 0, startTime, 0, true);
+            }
+        });
+
+        checkStartTimeFilter(null, null, F.asList(startTime1, startTime2));
+        checkStartTimeFilter(null, startTime1, F.asList(startTime1));
+        checkStartTimeFilter(startTime2, null, F.asList(startTime2));
+        checkStartTimeFilter(startTime1, startTime2, F.asList(startTime1, startTime2));
+        checkStartTimeFilter(startTime2 + 1, null, Collections.emptyList());
+        checkStartTimeFilter(null, startTime1 - 1, Collections.emptyList());
+    }
+
+    /** */
+    private void checkStartTimeFilter(Long fromArg, Long toArg, List<Long> expTimes) throws Exception {
+        List<OperationType> opsWithStartTime = F.asList(CACHE_GET, TX_COMMIT, TX_ROLLBACK, QUERY, TASK, JOB);
+
+        List<String> args = new LinkedList<>();
+
+        if (fromArg != null) {
+            args.add("--from");
+
+            args.add(fromArg.toString());
+        }
+
+        if (toArg != null) {
+            args.add("--to");
+
+            args.add(toArg.toString());
+        }
+
+        Map<Long, List<OperationType>> opsByTime = new HashMap<>();
+
+        for (Long time : expTimes)
+            opsByTime.put(time, new LinkedList<>(opsWithStartTime));
+
+        readStatistics(args, json -> {
+            OperationType op = OperationType.valueOf(json.get("op").asText());
+
+            if (opsWithStartTime.contains(op)) {
+                long startTime = json.get("startTime").asLong();
+
+                assertTrue("Unexpected startTime: " + startTime, opsByTime.containsKey(startTime));
+                assertTrue("Unexpected operation: " + op, opsByTime.get(startTime).remove(op));
+            }
+        });
+
+        assertTrue("Expected operations: " + opsByTime, opsByTime.values().stream().allMatch(List::isEmpty));
+    }
+
+    /** @throws Exception If failed. */
+    @Test
+    public void testCachesFilter() throws Exception {
+        String cache1 = "cache1";
+        String cache2 = "cache2";
+
+        createStatistics(writer -> {
+            for (String cache : new String[] {cache1, cache2}) {
+                writer.cacheStart(CU.cacheId(cache), cache);
+                writer.cacheOperation(CACHE_GET, CU.cacheId(cache), 0, 0);
+                writer.transaction(GridIntList.asList(CU.cacheId(cache)), 0, 0, true);
+                writer.transaction(GridIntList.asList(CU.cacheId(cache)), 0, 0, false);
+            }
+        });
+
+        checkCachesFilter(null, new String[] {cache1, cache2});
+        checkCachesFilter(new String[] {cache1}, new String[] {cache1});
+        checkCachesFilter(new String[] {cache2}, new String[] {cache2});
+        checkCachesFilter(new String[] {cache1, cache2}, new String[] {cache1, cache2});
+        checkCachesFilter(new String[] {"unknown_cache"}, new String[0]);
+    }
+
+    /** */
+    private void checkCachesFilter(String[] cachesArg, String[] expCaches) throws Exception {
+        List<OperationType> cacheIdOps = F.asList(CACHE_START, CACHE_GET, TX_COMMIT, TX_ROLLBACK);
+
+        List<String> args = new LinkedList<>();
+
+        if (cachesArg != null) {
+            args.add("--caches");
+
+            args.add(String.join(",", cachesArg));
+        }
+
+        Map<Integer, List<OperationType>> opsById = new HashMap<>();
+
+        for (String cache : expCaches)
+            opsById.put(CU.cacheId(cache), new LinkedList<>(cacheIdOps));
+
+        readStatistics(args, json -> {
+            OperationType op = OperationType.valueOf(json.get("op").asText());
+
+            Integer id = null;
+
+            if (OperationType.cacheOperation(op) || op == CACHE_START)
+                id = json.get("cacheId").asInt();
+            else if (OperationType.transactionOperation(op)) {
+                assertTrue(json.get("cacheIds").isArray());
+                assertEquals(1, json.get("cacheIds").size());
+
+                id = json.get("cacheIds").get(0).asInt();
+            }
+            else
+                fail("Unexpected operation: " + op);
+
+            assertTrue("Unexpected cache id: " + id, opsById.containsKey(id));
+            assertTrue("Unexpected operation: " + op, opsById.get(id).remove(op));
+        });
+
+        assertTrue("Expected operations: " + opsById, opsById.values().stream().allMatch(List::isEmpty));
+    }
+
+    /** Writes statistics through passed writer. */
+    private void createStatistics(Consumer<FilePerformanceStatisticsWriter> c) throws Exception {
+        FilePerformanceStatisticsWriter writer = new FilePerformanceStatisticsWriter(new TestKernalContext(NODE_ID));
+
+        writer.start();
+
+        waitForCondition(() -> U.field((Object)U.field(writer, "fileWriter"), "runner") != null, 30_000);
+
+        c.accept(writer);
+
+        writer.stop();
+    }
+
+    /**
+     * @param args Additional program arguments.
+     * @param c Consumer to handle operations.
+     * @throws Exception If failed.
+     */
+    private void readStatistics(List<String> args, Consumer<JsonNode> c) throws Exception {
+        File perfStatDir = new File(U.defaultWorkDirectory(), PERF_STAT_DIR);
+
+        assertTrue(perfStatDir.exists());
+
+        File out = new File(U.defaultWorkDirectory(), "report.txt");
+
+        U.delete(out);
+
+        List<String> pArgs = new LinkedList<>();
+
+        pArgs.add(perfStatDir.getAbsolutePath());
+        pArgs.add("--out");
+        pArgs.add(out.getAbsolutePath());
+
+        pArgs.addAll(args);
+
+        PerformanceStatisticsPrinter.main(pArgs.toArray(new String[0]));
+
+        assertTrue(out.exists());
+
+        ObjectMapper mapper = new ObjectMapper();
+
+        try (BufferedReader reader = new BufferedReader(new FileReader(out))) {
+            String line;
+
+            while ((line = reader.readLine()) != null) {
+                JsonNode json = mapper.readTree(line);
+
+                assertTrue(json.isObject());
+
+                UUID nodeId = UUID.fromString(json.get("nodeId").asText());
+
+                assertEquals(NODE_ID, nodeId);
+
+                c.accept(json);
+            }
+        }
+    }
+
+    /** Test kernal context. */
+    private static class TestKernalContext extends GridTestKernalContext {
+        /** Node ID. */
+        private final UUID nodeId;
+
+        /** @param nodeId Node ID. */
+        public TestKernalContext(UUID nodeId) {
+            super(new JavaLogger());
+
+            this.nodeId = nodeId;
+        }
+
+        /** {@inheritDoc} */
+        @Override public UUID localNodeId() {
+            return nodeId;
+        }
+    }
+}