Add history-view-related UMA metrics and histograms for locally managed users.

chrome/browser/history/history_database.cc

 // Copyright (c) 2012 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 "chrome/browser/history/history_database.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
+#include "base/time.h"
 #include "sql/transaction.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #endif
 
 namespace history {
 
 namespace {
 
 // Current version number. We write databases at the "current" version number,
 // but any previous version that can read the "compatible" one can make do with
 // or database without *too* many bad effects.
 static const int kCurrentVersionNumber = 23;
 static const int kCompatibleVersionNumber = 16;
 static const char kEarlyExpirationThresholdKey[] = "early_expiration_threshold";
 
 // Key in the meta table used to determine if we need to migrate thumbnails out
 // of history.
 static const char kNeedsThumbnailMigrationKey[] = "needs_thumbnail_migration";
 
 void ComputeDatabaseMetrics(const FilePath& history_name,
                             sql::Connection& db) {
   if (base::RandInt(1, 100) != 50)
     return;  // Only do this computation sometimes since it can be expensive.
 
+  base::TimeTicks start_time = base::TimeTicks::Now();
   int64 file_size = 0;
   if (!file_util::GetFileSize(history_name, &file_size))
     return;
   int file_mb = static_cast<int>(file_size / (1024 * 1024));
   UMA_HISTOGRAM_MEMORY_MB("History.DatabaseFileMB", file_mb);
 
   sql::Statement url_count(db.GetUniqueStatement("SELECT count(*) FROM urls"));
   if (!url_count.Step())
     return;
   UMA_HISTOGRAM_COUNTS("History.URLTableCount", url_count.ColumnInt(0));
 
   sql::Statement visit_count(db.GetUniqueStatement(
       "SELECT count(*) FROM visits"));
   if (!visit_count.Step())
     return;
   UMA_HISTOGRAM_COUNTS("History.VisitTableCount", visit_count.ColumnInt(0));
+
+  base::Time one_week_ago = base::Time::Now() - base::TimeDelta::FromDays(7);
+  sql::Statement weekly_visit_count(db.GetUniqueStatement(
+      "SELECT count(*) FROM visits WHERE visit_time > ?"));
+  weekly_visit_count.BindInt64(0, one_week_ago.ToInternalValue());
+  UMA_HISTOGRAM_COUNTS("History.WeeklyVisitCount",
+                       weekly_visit_count.ColumnInt(0));
+
+  base::Time one_month_ago = base::Time::Now() - base::TimeDelta::FromDays(30);
+  sql::Statement monthly_visit_count(db.GetUniqueStatement(
+      "SELECT count(*) FROM visits WHERE visit_time > ?"));
+  monthly_visit_count.BindInt64(0, one_month_ago.ToInternalValue());
+  UMA_HISTOGRAM_COUNTS("History.MonthlyVisitCount",
+                       monthly_visit_count.ColumnInt(0));
+
+  UMA_HISTOGRAM_TIMES("History.DatabaseBasicMetricsTime",
+                      base::TimeTicks::Now() - start_time);

[Scott Hess - ex-Googler, 2013/01/23 22:15:37]

Overall looks good.  Just a couple questions.

First, the file actually will have 30 days worth of data?  I never remember the
relationships between History, Archived History, and History Index.

Second, is this scan expected to be large for some users?  You could either
revise the scan to calculate both values in one pass, something like:
  SELECT sum(visit_time > ?), count(*) FROM visits WHERE visit_time > ?
where the first parameters is one_week_ago and the second is one_month_ago, or
(perhaps more easily) you could just have the second query only scan
one_month_ago -> one_week_ago, then add the results.  CPU-wise I expect they'll
be equivalent.

Hmm, poking around in my profiles, I'd say that the visit_time index is probably
small enough that the index would fit in the (rather large) cache.  In which
case just do what's easiest.  If you decide to stay with the current queries,
then re-use the statement by calling Reset() then binding the new value, rather
than having distinct-but-identical statements.

 }
 
 }  // namespace
 
 HistoryDatabase::HistoryDatabase()
     : needs_version_17_migration_(false) {
 }
 
 HistoryDatabase::~HistoryDatabase() {
 }
@@ skipping 303 matching lines @@
       "WHERE id IN (SELECT id FROM segment_usage WHERE time_slot > 0);"));
 
   // Erase all the full text index files. These will take a while to update and
   // are less important, so we just blow them away. Same with the archived
   // database.
   needs_version_17_migration_ = true;
 }
 #endif
 
 }  // namespace history