Add DBusStatistics and DBusLogSource to log and show dbus stats

dbus/dbus_statistics.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 "dbus/dbus_statistics.h"
+
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/stl_util.h"
+#include "base/stringprintf.h"
+
+namespace dbus {
+
+namespace {
+
+// Used to store dbus statistics sorted alphabetically by service, interface,
+// then method (using std::string <).
+struct Stat {
+  Stat(const std::string& service,
+       const std::string& interface,
+       const std::string& method)
+      : service(service),
+        interface(interface),
+        method(method),
+        sent_calls(0),
+        received_calls(0),
+        sent_blocking_calls(0) {
+  }
+  std::string service;
+  std::string interface;
+  std::string method;
+  int sent_calls;
+  int received_calls;
+  int sent_blocking_calls;
+
+  bool Compare(const Stat& other) const {
+    if (service != other.service)
+      return service < other.service;
+    if (interface != other.interface)
+      return interface < other.interface;
+    return method < other.method;
+  }
+
+  struct PtrCompare {
+    bool operator()(Stat* lhs, Stat* rhs) const {
+      DCHECK(lhs != NULL && rhs != NULL);

[gauravsh, 2012/11/12 21:41:58]

I'd be consistent with the pointer checks in the file (so this should be
DCHECK(lhs && rhs); 

[stevenjb, 2012/11/12 22:34:40]

Done.

+      return lhs->Compare(*rhs);
+    }
+  };
+};
+
+typedef std::set<Stat*, Stat::PtrCompare> StatSet;
+
+//------------------------------------------------------------------------------
+// DBusStatistics
+
+// Simple class for gathering DBus usage statistics.
+class DBusStatistics {
+ public:
+  DBusStatistics() : start_time_(base::Time::Now()) {
+  }
+
+  ~DBusStatistics() {
+    STLDeleteContainerPointers(stats_.begin(), stats_.end());
+  }
+
+  // Eunum to specify which field in Stat to incrament in AddStat

[gauravsh, 2012/11/12 21:41:58]

NIT: Enum, increment

[stevenjb, 2012/11/12 22:34:40]

Done.

+  enum StatType {
+    TYPE_SENT,
+    TYPE_RECEIVED,
+    TYPE_SENT_BLOCKING
+  };
+
+  // Add a call to |method| for |interface|. See also MethodCall in message.h.
+  void AddStat(const std::string& service,
+               const std::string& interface,
+               const std::string& method,
+               StatType type) {
+    Stat* stat = GetStat(service, interface, method, true);
+    if (type == TYPE_SENT)
+      ++stat->sent_calls;
+    else if (type == TYPE_RECEIVED)
+      ++stat->received_calls;
+    else if (type == TYPE_SENT_BLOCKING)
+      ++stat->sent_blocking_calls;
+    else
+      NOTREACHED();
+  }
+
+  // Look up the Stat entry in |stats_|. If |add_stat| is true, add a new entry
+  // if one does not already exist.
+  Stat* GetStat(const std::string& service,
+                const std::string& interface,
+                const std::string& method,
+                bool add_stat) {
+    scoped_ptr<Stat> stat(new Stat(service, interface, method));
+    StatSet::iterator found = stats_.find(stat.get());
+    if (found != stats_.end())
+      return *found;
+    if (!add_stat)
+      return NULL;
+    found = stats_.insert(stat.release()).first;
+    return *found;
+  }
+
+  StatSet& stats() { return stats_; }
+  base::Time start_time() { return start_time_; }
+
+ private:
+  StatSet stats_;
+  base::Time start_time_;
+
+  DISALLOW_COPY_AND_ASSIGN(DBusStatistics);
+};
+
+DBusStatistics* g_dbus_statistics = NULL;
+
+}  // namespace
+
+//------------------------------------------------------------------------------
+
+namespace statistics {
+
+void Initialize() {
+  if (g_dbus_statistics)
+    delete g_dbus_statistics;  // reset statistics
+  g_dbus_statistics = new DBusStatistics();
+}
+
+void Shutdown() {
+  delete g_dbus_statistics;
+  g_dbus_statistics = NULL;
+}
+
+void AddSentMethodCall(const std::string& service,
+                       const std::string& interface,
+                       const std::string& method) {
+  if (!g_dbus_statistics)
+    return;
+  g_dbus_statistics->AddStat(
+      service, interface, method, DBusStatistics::TYPE_SENT);
+}
+
+void AddReceivedMethodCall(const std::string& service,
+                           const std::string& interface,
+                           const std::string& method) {
+  if (!g_dbus_statistics)
+    return;
+  g_dbus_statistics->AddStat(
+      service, interface, method, DBusStatistics::TYPE_RECEIVED);
+}
+
+void AddBlockingSentMethodCall(const std::string& service,
+                               const std::string& interface,
+                               const std::string& method) {
+  if (!g_dbus_statistics)
+    return;
+  g_dbus_statistics->AddStat(
+      service, interface, method, DBusStatistics::TYPE_SENT_BLOCKING);
+}
+
+std::string GetAsString(ShowInString show, FormatString format) {
+  if (!g_dbus_statistics)
+    return "DBusStatistics not intitialized.";

[gauravsh, 2012/11/12 21:41:58]

NIT: initialized

[stevenjb, 2012/11/12 22:34:40]

Done.

+
+  const StatSet& stats = g_dbus_statistics->stats();
+  if (stats.empty())
+    return "No DBus calls.";
+
+  base::TimeDelta dtime = base::Time::Now() - g_dbus_statistics->start_time();
+  int dminutes = dtime.InMinutes();
+  dminutes = std::max(dminutes, 1);
+
+  std::string result;
+  int sent = 0, received = 0, sent_blocking = 0;
+  // Stats are stored in order by service, then interface, then method.
+  for (StatSet::const_iterator iter = stats.begin(); iter != stats.end(); ) {
+    StatSet::const_iterator cur_iter = iter++;

[gauravsh, 2012/11/12 21:41:58]

Please do not use the postincrement operator with iterator types.

[stevenjb, 2012/11/12 22:34:40]

Postincrament is exactly what we want here, (preincrament would be incorrect).

[gauravsh, 2012/11/12 23:07:34]

Sorry, I should have been clearer. Google C++/Chromium style specifies that
postincrement shouldn't be used for iterator/complex types - so I was asking to
rewrite this using preincrement.

+    const Stat* stat = *cur_iter;
+    sent += stat->sent_calls;
+    received += stat->received_calls;
+    sent_blocking += stat->sent_blocking_calls;
+    // If this is the last stat, or if the next stat should be on a different
+    // line, add a line to the result and clear the counts.
+    if (iter == stats.end() ||

[gauravsh, 2012/11/12 21:41:58]

I'd suggest inverting this conditional (and adding a continue) to get rid of one
level of nesting.

[stevenjb, 2012/11/12 22:34:40]

Good suggestion. Done.

+        (*iter)->service != stat->service ||
+        (show >= SHOW_SERVICE && (*iter)->interface != stat->interface) ||
+        (show >= SHOW_METHOD && (*iter)->method != stat->method)) {
+      if (!sent && !received && !sent_blocking)
+        continue;  // No stats collected for this line, skip it and continue.
+
+      std::string line;
+      if (show == SHOW_SERVICE) {
+        line += stat->service;
+      } else {
+        // The interface usually includes the service so don't show both.
+        line += stat->interface;
+        if (show >= SHOW_METHOD)
+          line += "." + stat->method;
+      }
+      line += StringPrintf(":");
+      if (sent_blocking) {
+        line += StringPrintf(" Sent (BLOCKING):");
+        if (format == FORMAT_TOTALS)
+          line += StringPrintf(" %d", sent_blocking);
+        else if (format == FORMAT_PER_MINUTE)
+          line += StringPrintf(" %d/min", sent_blocking / dminutes);
+        else if (format == FORMAT_ALL)
+          line += StringPrintf(" %d (%d/min)",
+                               sent_blocking, sent_blocking / dminutes);
+      }
+      if (sent) {
+        line += StringPrintf(" Sent:");
+        if (format == FORMAT_TOTALS)
+          line += StringPrintf(" %d", sent);
+        else if (format == FORMAT_PER_MINUTE)
+          line += StringPrintf(" %d/min", sent / dminutes);
+        else if (format == FORMAT_ALL)
+          line += StringPrintf(" %d (%d/min)", sent, sent / dminutes);
+      }
+      if (received) {
+        line += StringPrintf(" Received:");
+        if (format == FORMAT_TOTALS)
+          line += StringPrintf(" %d", received);
+        else if (format == FORMAT_PER_MINUTE)
+          line += StringPrintf(" %d/min", received / dminutes);
+        else if (format == FORMAT_ALL)
+          line += StringPrintf(" %d (%d/min)", received, received / dminutes);
+      }
+      result += line + "\n";
+      sent = 0;
+      sent_blocking = 0;
+      received = 0;
+    }
+  }
+  return result;
+}
+
+namespace testing {
+
+bool GetCalls(const std::string& service,
+              const std::string& interface,
+              const std::string& method,
+              int* sent,
+              int* received,
+              int* blocking) {
+  if (!g_dbus_statistics)
+    return false;
+  Stat* stat = g_dbus_statistics->GetStat(service, interface, method, false);
+  if (!stat)
+    return false;
+  *sent = stat->sent_calls;
+  *received = stat->received_calls;
+  *blocking = stat->sent_blocking_calls;
+  return true;
+}
+
+}  // namespace testing
+
+}  // namespace statistics
+}  // namespace dbus