Integrate Crashpad UMA

third_party/crashpad/crashpad/handler/handler_main.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed 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.
 
 #include "handler/handler_main.h"
 
 #include <getopt.h>
 #include <stdint.h>
 #include <stdlib.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
+#include "base/metrics/persistent_histogram_allocator.h"
 #include "base/scoped_generic.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "client/crash_report_database.h"
 #include "client/crashpad_client.h"
 #include "client/prune_crash_reports.h"
 #include "handler/crash_report_upload_thread.h"
 #include "handler/prune_crash_reports_thread.h"
 #include "tools/tool_support.h"
 #include "util/file/file_io.h"
@@ skipping 31 matching lines @@
 "\n"
 "      --annotation=KEY=VALUE  set a process annotation in each crash report\n"
 "      --database=PATH         store the crash report database at PATH\n"
 #if defined(OS_MACOSX)
 "      --handshake-fd=FD       establish communication with the client over FD\n"
 "      --mach-service=SERVICE  register SERVICE with the bootstrap server\n"
 #elif defined(OS_WIN)
 "      --handshake-handle=HANDLE\n"
 "                              create a new pipe and send its name via HANDLE\n"
 #endif  // OS_MACOSX
+"      --metrics-dir=DIR       store metrics files in DIR (only in Chromium)\n"
 "      --no-rate-limit         don't rate limit crash uploads\n"
 #if defined(OS_MACOSX)
 "      --reset-own-crash-exception-port-to-system-default\n"
 "                              reset the server's exception handler to default\n"
 #elif defined(OS_WIN)
 "      --pipe-name=PIPE        communicate with the client over PIPE\n"
 #endif  // OS_MACOSX
 "      --url=URL               send crash reports to this Breakpad server URL,\n"
 "                              only if uploads are enabled for the database\n"
 "      --help                  display this help and exit\n"
@@ skipping 38 matching lines @@
     // Long options without short equivalents.
     kOptionLastChar = 255,
     kOptionAnnotation,
     kOptionDatabase,
 #if defined(OS_MACOSX)
     kOptionHandshakeFD,
     kOptionMachService,
 #elif defined(OS_WIN)
     kOptionHandshakeHandle,
 #endif  // OS_MACOSX
+    kOptionMetrics,
     kOptionNoRateLimit,
 #if defined(OS_MACOSX)
     kOptionResetOwnCrashExceptionPortToSystemDefault,
 #elif defined(OS_WIN)
     kOptionPipeName,
 #endif  // OS_MACOSX
     kOptionURL,
 
     // Standard options.
     kOptionHelp = -2,
     kOptionVersion = -3,
   };
 
   struct {
     std::map<std::string, std::string> annotations;
     std::string url;
     const char* database;
+    const char* metrics;
 #if defined(OS_MACOSX)
     int handshake_fd;
     std::string mach_service;
     bool reset_own_crash_exception_port_to_system_default;
 #elif defined(OS_WIN)
     HANDLE handshake_handle;
     std::string pipe_name;
 #endif  // OS_MACOSX
     bool rate_limit;
   } options = {};
 #if defined(OS_MACOSX)
   options.handshake_fd = -1;
 #elif defined(OS_WIN)
   options.handshake_handle = INVALID_HANDLE_VALUE;
 #endif
   options.rate_limit = true;
 
   const option long_options[] = {
       {"annotation", required_argument, nullptr, kOptionAnnotation},
       {"database", required_argument, nullptr, kOptionDatabase},
 #if defined(OS_MACOSX)
       {"handshake-fd", required_argument, nullptr, kOptionHandshakeFD},
       {"mach-service", required_argument, nullptr, kOptionMachService},
 #elif defined(OS_WIN)
       {"handshake-handle", required_argument, nullptr, kOptionHandshakeHandle},
 #endif  // OS_MACOSX
+      {"metrics", required_argument, nullptr, kOptionMetrics},
       {"no-rate-limit", no_argument, nullptr, kOptionNoRateLimit},
 #if defined(OS_MACOSX)
       {"reset-own-crash-exception-port-to-system-default",
        no_argument,
        nullptr,
        kOptionResetOwnCrashExceptionPortToSystemDefault},
 #elif defined(OS_WIN)
       {"pipe-name", required_argument, nullptr, kOptionPipeName},
 #endif  // OS_MACOSX
       {"url", required_argument, nullptr, kOptionURL},
@@ skipping 44 matching lines @@
         unsigned int handle_uint;
         if (!StringToNumber(optarg, &handle_uint) ||
             (options.handshake_handle = IntToHandle(handle_uint)) ==
                 INVALID_HANDLE_VALUE) {
           ToolSupport::UsageHint(me, "--handshake-handle requires a HANDLE");
           return EXIT_FAILURE;
         }
         break;
       }
 #endif  // OS_MACOSX
+      case kOptionMetrics: {
+        options.metrics = optarg;
+        break;
+      }
       case kOptionNoRateLimit: {
         options.rate_limit = false;
         break;
       }
 #if defined(OS_MACOSX)
       case kOptionResetOwnCrashExceptionPortToSystemDefault: {
         options.reset_own_crash_exception_port_to_system_default = true;
         break;
       }
 #elif defined(OS_WIN)
@@ skipping 123 matching lines @@
       return EXIT_FAILURE;
     }
     if (!LoggingWriteFile(options.handshake_handle,
                           pipe_name.c_str(),
                           pipe_name.size() * sizeof(pipe_name[0]))) {
       return EXIT_FAILURE;
     }
   }
 #endif  // OS_MACOSX
 
+  base::GlobalHistogramAllocator* histogram_allocator = nullptr;
+  if (options.metrics) {
+    const base::FilePath metrics_dir(
+        ToolSupport::CommandLineArgumentToFilePathStringType(options.metrics));
+    const char kMetricsName[] = "CrashpadMetrics";
+    if (base::GlobalHistogramAllocator::CreateWithActiveFileInDir(
+            metrics_dir, 1 << 20, 0, kMetricsName)) {
+      histogram_allocator = base::GlobalHistogramAllocator::Get();
+      histogram_allocator->CreateTrackingHistograms(kMetricsName);
+    }
+  }
+
   std::unique_ptr<CrashReportDatabase> database(CrashReportDatabase::Initialize(
       base::FilePath(ToolSupport::CommandLineArgumentToFilePathStringType(
           options.database))));
   if (!database) {
     return EXIT_FAILURE;
   }
 
   // TODO(scottmg): options.rate_limit should be removed when we have a
   // configurable database setting to control upload limiting.
   // See https://crashpad.chromium.org/bug/23.
   CrashReportUploadThread upload_thread(
       database.get(), options.url, options.rate_limit);
   upload_thread.Start();
 
   PruneCrashReportThread prune_thread(database.get(),
                                       PruneCondition::GetDefault());
   prune_thread.Start();
 
   CrashReportExceptionHandler exception_handler(
       database.get(), &upload_thread, &options.annotations);
 
   exception_handler_server.Run(&exception_handler);
 
   upload_thread.Stop();
   prune_thread.Stop();
 
+  if (histogram_allocator)
+    histogram_allocator->DeletePersistentLocation();

[Mark Mentovai, 2016/09/15 00:08:55]

Optional: consider a scoper to do this instead. There’s already an early return
between where it’s set up and here, and although we’re usually thinking that the
process will just exit after that return, we have in fact made this a library
function and we’re not assured of the process’ lifetime after this function
returns.

[scottmg, 2016/09/15 00:14:47]

I wonder if we shouldn't do that, so that we gather the metrics for
not-quite-clean exits in case of database initialization failure? I'm not sure
if that's a good enough rationale for non-scoping.

+
   return EXIT_SUCCESS;
 }
 
 }  // namespace crashpad