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_sql(db.GetUniqueStatement(
+      "SELECT count(*) FROM visits WHERE visit_time > ?"));
+  weekly_visit_sql.BindInt64(0, one_week_ago.ToInternalValue());
+  int weekly_visit_count = weekly_visit_sql.ColumnInt(0);
+  UMA_HISTOGRAM_COUNTS("History.WeeklyVisitCount", weekly_visit_count);
+
+  base::Time one_month_ago = base::Time::Now() - base::TimeDelta::FromDays(30);
+  sql::Statement monthly_visit_sql(db.GetUniqueStatement(
+      "SELECT count(*) FROM visits WHERE visit_time > ? AND visit_time <= ?"));
+  monthly_visit_sql.BindInt64(0, one_month_ago.ToInternalValue());
+  monthly_visit_sql.BindInt64(1, one_week_ago.ToInternalValue());
+  UMA_HISTOGRAM_COUNTS("History.MonthlyVisitCount",
+                       monthly_visit_sql.ColumnInt(0) + weekly_visit_count);
+
+  UMA_HISTOGRAM_TIMES("History.DatabaseBasicMetricsTime",
+                      base::TimeTicks::Now() - start_time);
+
+  // Compute the advanced metrics even less often, pending timing data showing
+  // that's not necessary.
+  if (base::RandInt(1, 3) == 3) {
+    start_time = base::TimeTicks::Now();
+    sql::Statement url_sql(db.GetUniqueStatement(
+        "SELECT url, last_visit_time FROM urls WHERE last_visit_time > ? "
+        "ORDER BY last_visit_time DESC"));

[Scott Hess - ex-Googler, 2013/01/24 17:30:52]

I don't see an index on last_visit_time, so it seems likely that this is going
to request SQLite to scan everything into buffers then do a sort.  Since you
only want the sort to be able to detect the weekly threshold, and you're going
to scan everything anyhow, I think modifying the code below to track a local
weekly_url_count and weekly_hosts would probably be more efficient in CPU and
memory.

[Pam (message me for reviews), 2013/01/25 08:07:48]

Makes sense. Thanks for knowing way more about the SQLite internals than I do!

[Scott Hess - ex-Googler, 2013/01/25 16:15:49]

Unlike a server db like MYSQL, asking SQLite to do prep work on your behalf just
shifts it from here to there in-process - unless there's an index or something
which allows it to efficiently manage things.

+    url_sql.BindInt64(0, one_month_ago.ToInternalValue());
+
+    bool saved_weekly_counts = false;
+    int url_count = 0;
+    std::set<std::string> hosts;
+    while (url_sql.Step()) {
+      GURL url(url_sql.ColumnString(0));
+      base::Time visit_time =
+          base::Time::FromInternalValue(url_sql.ColumnInt64(1));
+      if (!saved_weekly_counts && visit_time < one_week_ago) {

[Scott Hess - ex-Googler, 2013/01/24 17:30:52]

Pedantic Man wants visit_time <= one_week_ago to match the sense of the earlier
partitioning.

[Pam (message me for reviews), 2013/01/25 08:07:48]

Now moot. The new > here matches the > for visits.

+        UMA_HISTOGRAM_COUNTS("History.WeeklyURLCount", url_count);
+        UMA_HISTOGRAM_COUNTS_10000("History.WeeklyHostCount", hosts.size());
+        saved_weekly_counts = true;
+      }
+      ++url_count;
+      hosts.insert(url.host());
+    }
+    UMA_HISTOGRAM_COUNTS("History.MonthlyURLCount", url_count);
+    UMA_HISTOGRAM_COUNTS_10000("History.MonthlyHostCount", hosts.size());
+    UMA_HISTOGRAM_TIMES("History.DatabaseAdvancedMetricsTime",
+                        base::TimeTicks::Now() - start_time);
+  }
 }
 
 }  // 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