Record UMA status on websql results (chrome)

content/common/web_database_observer_impl.cc

 // Copyright (c) 2011 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 "content/common/web_database_observer_impl.h"
 
+#include "base/metrics/histogram.h"
 #include "base/string16.h"
 #include "content/common/database_messages.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDatabase.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 
+using WebKit::WebDatabase;
+
+namespace {
+
+const int kResultHistogramSize = 50;
+const int kCallsiteHistogramSize = 10;
+
+int DetermineHistogramResult(int webSqlErrorCode, int sqliteErrorCode) {
+  // If we have a sqlite error, log it after trimming the extended bits.
+  // There are 26 possible values, but we leave room for some new ones.
+  if (sqliteErrorCode)
+    return std::min(sqliteErrorCode & 0xff, 30);
+
+  // Otherwise, webSqlErrorCode may be an SQLExceptionCode, SQLErrorCode
+  // or a DOMExceptionCode, or -1 for success.
+  if (webSqlErrorCode == -1)
+    return 0;  // no error
+
+  // SQLExceptionCode starts at 1000
+  if (webSqlErrorCode >= 1000)
+    webSqlErrorCode -= 1000;
+
+  return std::min(webSqlErrorCode + 30, kResultHistogramSize - 1);
+}
+
+}  // namespace
+
 WebDatabaseObserverImpl::WebDatabaseObserverImpl(
     IPC::Message::Sender* sender)
     : sender_(sender),
       open_connections_(new webkit_database::DatabaseConnectionsWrapper) {
 }
 
 WebDatabaseObserverImpl::~WebDatabaseObserverImpl() {
 }
 
 void WebDatabaseObserverImpl::databaseOpened(
-    const WebKit::WebDatabase& database) {
+    const WebDatabase& database) {
   string16 origin_identifier = database.securityOrigin().databaseIdentifier();
   string16 database_name = database.name();
   open_connections_->AddOpenConnection(origin_identifier, database_name);
   sender_->Send(new DatabaseHostMsg_Opened(
       origin_identifier, database_name,
       database.displayName(), database.estimatedSize()));
 }
 
 void WebDatabaseObserverImpl::databaseModified(
-    const WebKit::WebDatabase& database) {
+    const WebDatabase& database) {
   sender_->Send(new DatabaseHostMsg_Modified(
       database.securityOrigin().databaseIdentifier(), database.name()));
 }
 
 void WebDatabaseObserverImpl::databaseClosed(
-    const WebKit::WebDatabase& database) {
+    const WebDatabase& database) {
   string16 origin_identifier = database.securityOrigin().databaseIdentifier();
   string16 database_name = database.name();
   sender_->Send(new DatabaseHostMsg_Closed(
       origin_identifier, database_name));
   open_connections_->RemoveOpenConnection(origin_identifier, database_name);
 }
 
+void WebDatabaseObserverImpl::reportOpenDatabaseResult(
+    const WebDatabase& database, int callsite, int webSqlErrorCode,
+    int sqliteErrorCode) {
+  DCHECK(callsite < kCallsiteHistogramSize);

[ramant (doing other things), 2011/11/29 23:29:36]

nit:

could we define a routine that takes the histrogram names as arguments and could
the following code be made smaller?

something like 
RecordHistogramData(
    database,
    callsite, 
    webSqlErrorCode,
    sqliteErrorCode 
    histogram_name_sync_prefix, 
    histogram_name_async_prefix)

In reportChangeVersionResult
we call RecordHistogramData(database, callsite, webSqlErrorCode,
sqliteErrorCode,  "websql.Sync.ChangeVersionResult",
"websql.Async.ChangeVersionResult")
   
In reportStartTransactionResult
we call RecordHistogramData(database, callsite, webSqlErrorCode,
sqliteErrorCode,  "websql.Sync.BeginResult", "websql.Async.BeginResult")

thanks

[michaeln, 2011/11/29 23:50:13]

I believe the histogram names can't vary for a particular macro usage...

    // Ensure calling contract is upheld, and the name does NOT vary.
    DCHECK(histogram_pointer->histogram_name() == constant_histogram_name);

... is that not right?

If that's right, i don't think i can do quite what you suggest (call a common
helper function). I could come up with a template driven means of generating a
macro per name if you think its worth it. After compilation of the expanded
templates, the binary code size would be pretty much the same, but there could
be less source code.

[ramant (doing other things), 2011/11/30 00:13:21]

We have to define a macro. It is your call.

+  int result = DetermineHistogramResult(webSqlErrorCode, sqliteErrorCode);
+  if (database.isSyncDatabase()) {
+    UMA_HISTOGRAM_ENUMERATION("websql.Sync.OpenResult",
+                              result, kResultHistogramSize);
+    if (result) {
+      UMA_HISTOGRAM_ENUMERATION("websql.Sync.OpenResult.ErrorSite",
+                                callsite, kCallsiteHistogramSize);
+    }
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("websql.Async.OpenResult",
+                              result, kResultHistogramSize);
+    if (result) {
+      UMA_HISTOGRAM_ENUMERATION("websql.Async.OpenResult.ErrorSite",
+                                callsite, kCallsiteHistogramSize);
+    }
+  }
+}
+
+void WebDatabaseObserverImpl::reportChangeVersionResult(
+    const WebDatabase& database, int callsite, int webSqlErrorCode,
+    int sqliteErrorCode) {
+  DCHECK(callsite < kCallsiteHistogramSize);
+  int result = DetermineHistogramResult(webSqlErrorCode, sqliteErrorCode);
+  if (database.isSyncDatabase()) {
+    UMA_HISTOGRAM_ENUMERATION("websql.Sync.ChangeVersionResult",
+                              result, kResultHistogramSize);
+    if (result) {
+      UMA_HISTOGRAM_ENUMERATION("websql.Sync.ChangeVersionResult.ErrorSite",
+                                callsite, kCallsiteHistogramSize);
+    }
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("websql.Async.ChangeVersionResult",
+                              result, kResultHistogramSize);
+    if (result) {
+      UMA_HISTOGRAM_ENUMERATION("websql.Async.ChangeVersionResult.ErrorSite",
+                                callsite, kCallsiteHistogramSize);
+    }
+  }
+}
+
+void WebDatabaseObserverImpl::reportStartTransactionResult(
+    const WebDatabase& database, int callsite, int webSqlErrorCode,
+    int sqliteErrorCode) {
+  DCHECK(callsite < kCallsiteHistogramSize);
+  int result = DetermineHistogramResult(webSqlErrorCode, sqliteErrorCode);
+  if (database.isSyncDatabase()) {
+    UMA_HISTOGRAM_ENUMERATION("websql.Sync.BeginResult",
+                              result, kResultHistogramSize);
+    if (result) {
+      UMA_HISTOGRAM_ENUMERATION("websql.Sync.BeginResult.ErrorSite",
+                                callsite, kCallsiteHistogramSize);
+    }
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("websql.Async.BeginResult",
+                              result, kResultHistogramSize);
+    if (result) {
+      UMA_HISTOGRAM_ENUMERATION("websql.Async.BeginResult.ErrorSite",
+                                callsite, kCallsiteHistogramSize);
+    }
+  }
+}
+
+void WebDatabaseObserverImpl::reportCommitTransactionResult(
+    const WebDatabase& database, int callsite, int webSqlErrorCode,
+    int sqliteErrorCode) {
+  DCHECK(callsite < kCallsiteHistogramSize);
+  int result = DetermineHistogramResult(webSqlErrorCode, sqliteErrorCode);
+  if (database.isSyncDatabase()) {
+    UMA_HISTOGRAM_ENUMERATION("websql.Sync.CommitResult",
+                              result, kResultHistogramSize);
+    if (result) {
+      UMA_HISTOGRAM_ENUMERATION("websql.Sync.CommitResult.ErrorSite",
+                                callsite, kCallsiteHistogramSize);
+    }
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("websql.Async.CommitResult", result,
+                              result, kResultHistogramSize);
+    if (result) {
+      UMA_HISTOGRAM_ENUMERATION("websql.Async.CommitResult.ErrorSite",
+                                callsite, kCallsiteHistogramSize);
+    }
+  }
+}
+
+void WebDatabaseObserverImpl::reportExecuteStatementResult(
+    const WebDatabase& database, int callsite, int webSqlErrorCode,
+    int sqliteErrorCode) {
+  DCHECK(callsite < kCallsiteHistogramSize);
+  int result = DetermineHistogramResult(webSqlErrorCode, sqliteErrorCode);
+  if (database.isSyncDatabase()) {
+    UMA_HISTOGRAM_ENUMERATION("websql.Sync.StatementResult",
+                              result, kHistogramSize);
+    if (result) {
+      UMA_HISTOGRAM_ENUMERATION("websql.Sync.StatementResult.ErrorSite",
+                                callsite, kCallsiteHistogramSize);
+    }
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("websql.Async.StatementResult",
+                              result, kResultHistogramSize);
+    if (result) {
+      UMA_HISTOGRAM_ENUMERATION("websql.Async.StatementResult.ErrorSite",
+                                callsite, kCallsiteHistogramSize);
+    }
+  }
+}
+
+void WebDatabaseObserverImpl::reportVacuumDatabaseResult(
+    const WebDatabase& database, int sqliteErrorCode) {
+  int result = DetermineHistogramResult(-1, sqliteErrorCode);
+  if (database.isSyncDatabase()) {
+    UMA_HISTOGRAM_ENUMERATION("websql.Sync.VacuumResult",
+                              result, kResultHistogramSize);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("websql.Async.VacuumResult",
+                              result, kResultHistogramSize);
+  }
+}
+
 void WebDatabaseObserverImpl::WaitForAllDatabasesToClose() {
   open_connections_->WaitForAllDatabasesToClose();
 }