Test launcher: add histograms

base/test/launcher/test_launcher.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/test/launcher/test_launcher.h"
 
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/format_macros.h"
 #include "base/hash.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
+#include "base/metrics/histogram_macros_local.h"
+#include "base/metrics/statistics_recorder.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringize_macros.h"
 #include "base/strings/stringprintf.h"
@@ skipping 34 matching lines @@
 const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
 // The environment variable name for the test shard index.
 const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
 
 namespace {
 
 // Global tag for test runs where the results are incomplete or unreliable
 // for any reason, e.g. early exit because of too many broken tests.
 const char kUnreliableResultsTag[] = "UNRELIABLE_RESULTS";
 
+// Name of the local histogram to measure test output size.
+const char kOutputSizeHistogramName[] = "TestLauncher.TestOutputSize";
+
 // Maximum time of no output after which we print list of processes still
 // running. This deliberately doesn't use TestTimeouts (which is otherwise
 // a recommended solution), because they can be increased. This would defeat
 // the purpose of this timeout, which is 1) to avoid buildbot "no output for
 // X seconds" timeout killing the process 2) help communicate status of
 // the test launcher to people looking at the output (no output for a long
 // time is mysterious and gives no info about what is happening) 3) help
 // debugging in case the process hangs anyway.
 const int kOutputTimeoutSeconds = 15;
 
@@ skipping 447 matching lines @@
   ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&TestLauncher::RunTestIteration, Unretained(this)));
 
   RunLoop().Run();
 
   if (requested_cycles != 1)
     results_tracker_.PrintSummaryOfAllIterations();
 
   MaybeSaveSummaryAsJSON(std::vector<std::string>());
 
+  std::string output_histogram;
+  StatisticsRecorder::WriteGraph(kOutputSizeHistogramName, &output_histogram);
+  fprintf(stdout, "%s", output_histogram.c_str());
+  fflush(stdout);
+
   return run_result_;
 }
 
 void TestLauncher::LaunchChildGTestProcess(
     const CommandLine& command_line,
     const std::string& wrapper,
     TimeDelta timeout,
     const LaunchOptions& options,
     const GTestProcessCompletedCallback& completed_callback,
     const GTestProcessLaunchedCallback& launched_callback) {
@@ skipping 15 matching lines @@
            Bind(&TestLauncher::OnLaunchTestProcessFinished, Unretained(this),
                 completed_callback),
            launched_callback));
 }
 
 void TestLauncher::OnTestFinished(const TestResult& original_result) {
   ++test_finished_count_;
 
   TestResult result(original_result);
 
+  LOCAL_HISTOGRAM_CUSTOM_COUNTS(
+      kOutputSizeHistogramName, result.output_snippet.length(),
+      1, 10000000, 50);
   if (result.output_snippet.length() > kOutputSnippetBytesLimit) {
     if (result.status == TestResult::TEST_SUCCESS)
       result.status = TestResult::TEST_EXCESSIVE_OUTPUT;
     result.output_snippet = StringPrintf(
         "<truncated (%" PRIuS " bytes)>\n", result.output_snippet.length()) +
         result.output_snippet.substr(
             result.output_snippet.length() - kOutputSnippetLinesLimit) +
         "\n";
   }
 
@@ skipping 349 matching lines @@
 
   // CPU-related tags.
 #if defined(ARCH_CPU_32_BITS)
   results_tracker_.AddGlobalTag("CPU_32_BITS");
 #endif
 
 #if defined(ARCH_CPU_64_BITS)
   results_tracker_.AddGlobalTag("CPU_64_BITS");
 #endif
 
+  StatisticsRecorder::Initialize();
+
   return true;
 }
 
 void TestLauncher::RunTests() {
   std::vector<std::string> test_names;
   for (size_t i = 0; i < tests_.size(); i++) {
     std::string test_name = FormatFullTestName(
         tests_[i].test_case_name, tests_[i].test_name);
 
     results_tracker_.AddTest(test_name, tests_[i].file, tests_[i].line);
@@ skipping 199 matching lines @@
   }
 
   std::string snippet(full_output.substr(run_pos));
   if (end_pos != std::string::npos)
     snippet = full_output.substr(run_pos, end_pos - run_pos);
 
   return snippet;
 }
 
 }  // namespace base