21 files changed, 222 insertions, 222 deletions

diff --git a/src/client/Client.cc b/src/client/Client.cc
index d55e77f644b..6806a9d36fd 100644
--- a/src/client/Client.cc
+++ b/src/client/Client.cc
@@ -73,7 +73,7 @@ using namespace std;
 
 // static logger
 Mutex client_logger_lock("client_logger_lock");
-ProfLogger  *client_logger = 0;
+PerfCounters  *client_logger = 0;
 
 
 
@@ -309,7 +309,7 @@ void Client::init()
   char hostname[80];
   gethostname(hostname, 79);
   snprintf(s, sizeof(s), "clients.%s.%d", hostname, getpid());
-  ProfLoggerBuilder plb(cct, s, l_c_first, l_c_last);
+  PerfCountersBuilder plb(cct, s, l_c_first, l_c_last);
   if (client_logger == 0) {
     plb.add_fl_avg(l_c_reply, "reply");
     plb.add_fl_avg(l_c_lat, "lat");
@@ -317,7 +317,7 @@ void Client::init()
     plb.add_fl_avg(l_c_owrlat, "owrlat");
     plb.add_fl_avg(l_c_ordlat, "ordlat");
     
-    client_logger = plb.create_proflogger();
+    client_logger = plb.create_perf_counters();
   }
   client_logger_lock.Unlock();
 }
diff --git a/src/client/Client.h b/src/client/Client.h
index b20201b3aa6..77412c21512 100644
--- a/src/client/Client.h
+++ b/src/client/Client.h
@@ -77,7 +77,7 @@ class Filer;
 class Objecter;
 class ObjectCacher;
 
-extern class ProfLogger  *client_logger;
+extern class PerfCounters  *client_logger;
 
 
 // ============================================
diff --git a/src/common/admin_socket.cc b/src/common/admin_socket.cc
index 579741a9e87..659bacf2946 100644
--- a/src/common/admin_socket.cc
+++ b/src/common/admin_socket.cc
@@ -273,7 +273,7 @@ private:
     std::vector<char> buffer;
     buffer.reserve(512);
 
-    ProfLoggerCollection *coll = m_parent->m_cct->GetProfLoggerCollection();
+    PerfCountersCollection *coll = m_parent->m_cct->GetPerfCountersCollection();
     if (coll) {
       coll->write_json_to_buf(buffer);
     }
diff --git a/src/common/ceph_context.cc b/src/common/ceph_context.cc
index 0020bab3210..4c2a65327f1 100644
--- a/src/common/ceph_context.cc
+++ b/src/common/ceph_context.cc
@@ -80,10 +80,10 @@ CephContext(uint32_t module_type_)
     _module_type(module_type_),
     _service_thread(NULL),
     _admin_socket_config_obs(NULL),
-    _prof_logger_collection(NULL)
+    _perf_counters_collection(NULL)
 {
   pthread_spin_init(&_service_thread_lock, PTHREAD_PROCESS_SHARED);
-  _prof_logger_collection = new ProfLoggerCollection(this);
+  _perf_counters_collection = new PerfCountersCollection(this);
   _conf->add_observer(_doss);
   _admin_socket_config_obs = new AdminSocketConfigObs(this);
   _conf->add_observer(_admin_socket_config_obs);
@@ -97,11 +97,11 @@ CephContext::
   _conf->remove_observer(_admin_socket_config_obs);
   _conf->remove_observer(_doss);
 
-  delete _prof_logger_collection;
-  _prof_logger_collection = NULL;
+  delete _perf_counters_collection;
+  _perf_counters_collection = NULL;
 
-  delete _prof_logger_conf_obs;
-  _prof_logger_conf_obs = NULL;
+  delete _perf_counters_conf_obs;
+  _perf_counters_conf_obs = NULL;
 
   delete _doss;
   _doss = NULL;
@@ -186,8 +186,8 @@ set_module_type(uint32_t module_type_)
   _module_type = module_type_;
 }
 
-ProfLoggerCollection *CephContext::
-GetProfLoggerCollection()
+PerfCountersCollection *CephContext::
+GetPerfCountersCollection()
 {
-  return _prof_logger_collection;
+  return _perf_counters_collection;
 }
diff --git a/src/common/ceph_context.h b/src/common/ceph_context.h
index ca3f775d061..522e6506a28 100644
--- a/src/common/ceph_context.h
+++ b/src/common/ceph_context.h
@@ -25,7 +25,7 @@ class DoutStreambuf;
 class AdminSocketConfigObs;
 class CephContextServiceThread;
 class DoutLocker;
-class ProfLoggerCollection;
+class PerfCountersCollection;
 class md_config_obs_t;
 class md_config_t;
 
@@ -62,8 +62,8 @@ public:
   /* Set module type (TODO: remove) */
   void set_module_type(uint32_t module_type_);
 
-  /* Get the ProfLoggerCollection of this CephContext */
-  ProfLoggerCollection *GetProfLoggerCollection();
+  /* Get the PerfCountersCollection of this CephContext */
+  PerfCountersCollection *GetPerfCountersCollection();
 
 private:
   CephContext(const CephContext &rhs);
@@ -86,9 +86,9 @@ private:
   pthread_spinlock_t _service_thread_lock;
 
   /* The collection of profiling loggers associated with this context */
-  ProfLoggerCollection *_prof_logger_collection;
+  PerfCountersCollection *_perf_counters_collection;
 
-  md_config_obs_t *_prof_logger_conf_obs;
+  md_config_obs_t *_perf_counters_conf_obs;
 };
 
 #endif
diff --git a/src/common/perf_counters.cc b/src/common/perf_counters.cc
index 37a38bb6ca9..d11ee89d974 100644
--- a/src/common/perf_counters.cc
+++ b/src/common/perf_counters.cc
@@ -35,67 +35,67 @@
 
 using std::ostringstream;
 
-enum prof_log_data_any_t {
-  PROF_LOG_DATA_ANY_NONE,
-  PROF_LOG_DATA_ANY_U64,
-  PROF_LOG_DATA_ANY_DOUBLE
+enum perf_counters_data_any_t {
+  PERF_COUNTERS_DATA_ANY_NONE,
+  PERF_COUNTERS_DATA_ANY_U64,
+  PERF_COUNTERS_DATA_ANY_DOUBLE
 };
 
-ProfLoggerCollection::
-ProfLoggerCollection(CephContext *cct)
+PerfCountersCollection::
+PerfCountersCollection(CephContext *cct)
   : m_cct(cct),
-    m_lock("ProfLoggerCollection")
+    m_lock("PerfCountersCollection")
 {
 }
 
-ProfLoggerCollection::
-~ProfLoggerCollection()
+PerfCountersCollection::
+~PerfCountersCollection()
 {
   Mutex::Locker lck(m_lock);
-  for (prof_logger_set_t::iterator l = m_loggers.begin();
+  for (perf_counters_set_t::iterator l = m_loggers.begin();
 	l != m_loggers.end(); ++l) {
     delete *l;
   }
   m_loggers.clear();
 }
 
-void ProfLoggerCollection::
-logger_add(class ProfLogger *l)
+void PerfCountersCollection::
+logger_add(class PerfCounters *l)
 {
   Mutex::Locker lck(m_lock);
-  prof_logger_set_t::iterator i = m_loggers.find(l);
+  perf_counters_set_t::iterator i = m_loggers.find(l);
   assert(i == m_loggers.end());
   m_loggers.insert(l);
 }
 
-void ProfLoggerCollection::
-logger_remove(class ProfLogger *l)
+void PerfCountersCollection::
+logger_remove(class PerfCounters *l)
 {
   Mutex::Locker lck(m_lock);
-  prof_logger_set_t::iterator i = m_loggers.find(l);
+  perf_counters_set_t::iterator i = m_loggers.find(l);
   assert(i != m_loggers.end());
   delete *i;
   m_loggers.erase(i);
 }
 
-void ProfLoggerCollection::
+void PerfCountersCollection::
 logger_clear()
 {
   Mutex::Locker lck(m_lock);
-  prof_logger_set_t::iterator i = m_loggers.begin();
-  prof_logger_set_t::iterator i_end = m_loggers.end();
+  perf_counters_set_t::iterator i = m_loggers.begin();
+  perf_counters_set_t::iterator i_end = m_loggers.end();
   for (; i != i_end; ) {
     delete *i;
     m_loggers.erase(i++);
   }
 }
 
-void ProfLoggerCollection::
+void PerfCountersCollection::
 write_json_to_buf(std::vector <char> &buffer)
 {
   Mutex::Locker lck(m_lock);
   buffer.push_back('{');
-  for (prof_logger_set_t::iterator l = m_loggers.begin();
+  for (perf_counters_set_t::iterator l = m_loggers.begin();
        l != m_loggers.end(); ++l)
   {
     (*l)->write_json_to_buf(buffer);
@@ -104,87 +104,87 @@ write_json_to_buf(std::vector <char> &buffer)
   buffer.push_back('\0');
 }
 
-ProfLogger::
-~ProfLogger()
+PerfCounters::
+~PerfCounters()
 {
 }
 
-void ProfLogger::
+void PerfCounters::
 inc(int idx, uint64_t amt)
 {
   Mutex::Locker lck(m_lock);
   assert(idx > m_lower_bound);
   assert(idx < m_upper_bound);
-  prof_log_data_any_d& data(m_data[idx - m_lower_bound - 1]);
-  if (data.type != PROF_LOG_DATA_ANY_U64)
+  perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
+  if (data.type != PERF_COUNTERS_DATA_ANY_U64)
     return;
   data.u.u64 += amt;
   if (data.count != COUNT_DISABLED)
     data.count++;
 }
 
-void ProfLogger::
+void PerfCounters::
 set(int idx, uint64_t amt)
 {
   Mutex::Locker lck(m_lock);
   assert(idx > m_lower_bound);
   assert(idx < m_upper_bound);
-  prof_log_data_any_d& data(m_data[idx - m_lower_bound - 1]);
-  if (data.type != PROF_LOG_DATA_ANY_U64)
+  perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
+  if (data.type != PERF_COUNTERS_DATA_ANY_U64)
     return;
   data.u.u64 = amt;
   if (data.count != COUNT_DISABLED)
     data.count++;
 }
 
-uint64_t ProfLogger::
+uint64_t PerfCounters::
 get(int idx) const
 {
   Mutex::Locker lck(m_lock);
   assert(idx > m_lower_bound);
   assert(idx < m_upper_bound);
-  const prof_log_data_any_d& data(m_data[idx - m_lower_bound - 1]);
-  if (data.type != PROF_LOG_DATA_ANY_DOUBLE)
+  const perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
+  if (data.type != PERF_COUNTERS_DATA_ANY_DOUBLE)
     return 0;
   return data.u.u64;
 }
 
-void ProfLogger::
+void PerfCounters::
 finc(int idx, double amt)
 {
   Mutex::Locker lck(m_lock);
   assert(idx > m_lower_bound);
   assert(idx < m_upper_bound);
-  prof_log_data_any_d& data(m_data[idx - m_lower_bound - 1]);
-  if (data.type != PROF_LOG_DATA_ANY_DOUBLE)
+  perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
+  if (data.type != PERF_COUNTERS_DATA_ANY_DOUBLE)
     return;
   data.u.dbl += amt;
   if (data.count != COUNT_DISABLED)
     data.count++;
 }
 
-void ProfLogger::
+void PerfCounters::
 fset(int idx, double amt)
 {
   Mutex::Locker lck(m_lock);
   assert(idx > m_lower_bound);
   assert(idx < m_upper_bound);
-  prof_log_data_any_d& data(m_data[idx - m_lower_bound - 1]);
-  if (data.type != PROF_LOG_DATA_ANY_DOUBLE)
+  perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
+  if (data.type != PERF_COUNTERS_DATA_ANY_DOUBLE)
     return;
   data.u.dbl = amt;
   if (data.count != COUNT_DISABLED)
     data.count++;
 }
 
-double ProfLogger::
+double PerfCounters::
 fget(int idx) const
 {
   Mutex::Locker lck(m_lock);
   assert(idx > m_lower_bound);
   assert(idx < m_upper_bound);
-  const prof_log_data_any_d& data(m_data[idx - m_lower_bound - 1]);
-  if (data.type != PROF_LOG_DATA_ANY_DOUBLE)
+  const perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
+  if (data.type != PERF_COUNTERS_DATA_ANY_DOUBLE)
     return 0.0;
   return data.u.dbl;
 }
@@ -197,7 +197,7 @@ static inline void append_to_vector(std::vector <char> &buffer, char *buf)
   memcpy(&buffer[sz], buf, strlen_buf);
 }
 
-void ProfLogger::
+void PerfCounters::
 write_json_to_buf(std::vector <char> &buffer)
 {
   char buf[512];
@@ -206,19 +206,19 @@ write_json_to_buf(std::vector <char> &buffer)
   snprintf(buf, sizeof(buf), "\"%s\":{", m_name.c_str());
   append_to_vector(buffer, buf);
 
-  prof_log_data_vec_t::const_iterator d = m_data.begin();
-  prof_log_data_vec_t::const_iterator d_end = m_data.end();
+  perf_counter_data_vec_t::const_iterator d = m_data.begin();
+  perf_counter_data_vec_t::const_iterator d_end = m_data.end();
   for (; d != d_end; ++d) {
-    const prof_log_data_any_d &data(*d);
+    const perf_counter_data_any_d &data(*d);
     buf[0] = '\0';
     if (d->count != COUNT_DISABLED) {
       switch (d->type) {
-	case PROF_LOG_DATA_ANY_U64:
+	case PERF_COUNTERS_DATA_ANY_U64:
 	  snprintf(buf, sizeof(buf), "\"%s\":{\"count\":%" PRId64 ","
 		  "\"sum\":%" PRId64 "},", 
 		  data.name, data.count, data.u.u64);
 	  break;
-	case PROF_LOG_DATA_ANY_DOUBLE:
+	case PERF_COUNTERS_DATA_ANY_DOUBLE:
 	  snprintf(buf, sizeof(buf), "\"%s\":{\"count\":%" PRId64 ","
 		  "\"sum\":%g},",
 		  data.name, data.count, data.u.dbl);
@@ -230,11 +230,11 @@ write_json_to_buf(std::vector <char> &buffer)
     }
     else {
       switch (d->type) {
-	case PROF_LOG_DATA_ANY_U64:
+	case PERF_COUNTERS_DATA_ANY_U64:
 	  snprintf(buf, sizeof(buf), "\"%s\":%" PRId64 ",",
 		   data.name, data.u.u64);
 	  break;
-	case PROF_LOG_DATA_ANY_DOUBLE:
+	case PERF_COUNTERS_DATA_ANY_DOUBLE:
 	  snprintf(buf, sizeof(buf), "\"%s\":%g,", data.name, data.u.dbl);
 	  break;
 	default:
@@ -249,89 +249,89 @@ write_json_to_buf(std::vector <char> &buffer)
   buffer.push_back(',');
 }
 
-const std::string &ProfLogger::
+const std::string &PerfCounters::
 get_name() const
 {
   return m_name;
 }
 
-ProfLogger::
-ProfLogger(CephContext *cct, const std::string &name,
+PerfCounters::
+PerfCounters(CephContext *cct, const std::string &name,
 	   int lower_bound, int upper_bound)
   : m_cct(cct),
     m_lower_bound(lower_bound),
     m_upper_bound(upper_bound),
     m_name(name.c_str()),
-    m_lock_name(std::string("ProfLogger::") + name.c_str()),
+    m_lock_name(std::string("PerfCounters::") + name.c_str()),
     m_lock(m_lock_name.c_str())
 {
   m_data.resize(upper_bound - lower_bound - 1);
 }
 
-ProfLogger::prof_log_data_any_d::
-prof_log_data_any_d()
+PerfCounters::perf_counter_data_any_d::
+perf_counter_data_any_d()
   : name(NULL),
-    type(PROF_LOG_DATA_ANY_NONE),
+    type(PERF_COUNTERS_DATA_ANY_NONE),
     count(COUNT_DISABLED)
 {
   memset(&u, 0, sizeof(u));
 }
 
-ProfLoggerBuilder::
-ProfLoggerBuilder(CephContext *cct, const std::string &name,
+PerfCountersBuilder::
+PerfCountersBuilder(CephContext *cct, const std::string &name,
                   int first, int last)
-  : m_prof_logger(new ProfLogger(cct, name, first, last))
+  : m_perf_counters(new PerfCounters(cct, name, first, last))
 {
 }
 
-ProfLoggerBuilder::
-~ProfLoggerBuilder()
+PerfCountersBuilder::
+~PerfCountersBuilder()
 {
-  if (m_prof_logger)
-    delete m_prof_logger;
-  m_prof_logger = NULL;
+  if (m_perf_counters)
+    delete m_perf_counters;
+  m_perf_counters = NULL;
 }
 
-void ProfLoggerBuilder::
+void PerfCountersBuilder::
 add_u64(int idx, const char *name)
 {
-  add_impl(idx, name, PROF_LOG_DATA_ANY_U64, COUNT_DISABLED);
+  add_impl(idx, name, PERF_COUNTERS_DATA_ANY_U64, COUNT_DISABLED);
 }
 
-void ProfLoggerBuilder::
+void PerfCountersBuilder::
 add_fl(int idx, const char *name)
 {
-  add_impl(idx, name, PROF_LOG_DATA_ANY_DOUBLE, COUNT_DISABLED);
+  add_impl(idx, name, PERF_COUNTERS_DATA_ANY_DOUBLE, COUNT_DISABLED);
 }
 
-void ProfLoggerBuilder::
+void PerfCountersBuilder::
 add_fl_avg(int idx, const char *name)
 {
-  add_impl(idx, name, PROF_LOG_DATA_ANY_DOUBLE, 0);
+  add_impl(idx, name, PERF_COUNTERS_DATA_ANY_DOUBLE, 0);
 }
 
-void ProfLoggerBuilder::
+void PerfCountersBuilder::
 add_impl(int idx, const char *name, int ty, uint64_t count)
 {
-  assert(idx > m_prof_logger->m_lower_bound);
-  assert(idx < m_prof_logger->m_upper_bound);
-  ProfLogger::prof_log_data_vec_t &vec(m_prof_logger->m_data);
-  ProfLogger::prof_log_data_any_d
-    &data(vec[idx - m_prof_logger->m_lower_bound - 1]);
+  assert(idx > m_perf_counters->m_lower_bound);
+  assert(idx < m_perf_counters->m_upper_bound);
+  PerfCounters::perf_counter_data_vec_t &vec(m_perf_counters->m_data);
+  PerfCounters::perf_counter_data_any_d
+    &data(vec[idx - m_perf_counters->m_lower_bound - 1]);
   data.name = name;
   data.type = ty;
   data.count = count;
 }
 
-ProfLogger *ProfLoggerBuilder::
-create_proflogger()
+PerfCounters *PerfCountersBuilder::
+create_perf_counters()
 {
-  ProfLogger::prof_log_data_vec_t::const_iterator d = m_prof_logger->m_data.begin();
-  ProfLogger::prof_log_data_vec_t::const_iterator d_end = m_prof_logger->m_data.end();
+  PerfCounters::perf_counter_data_vec_t::const_iterator d = m_perf_counters->m_data.begin();
+  PerfCounters::perf_counter_data_vec_t::const_iterator d_end = m_perf_counters->m_data.end();
   for (; d != d_end; ++d) {
-    assert(d->type != PROF_LOG_DATA_ANY_NONE);
+    assert(d->type != PERF_COUNTERS_DATA_ANY_NONE);
   }
-  ProfLogger *ret = m_prof_logger;
-  m_prof_logger = NULL;
+  PerfCounters *ret = m_perf_counters;
+  m_perf_counters = NULL;
   return ret;
 }
diff --git a/src/common/perf_counters.h b/src/common/perf_counters.h
index 65dba0bf4fd..c7719dd2c65 100644
--- a/src/common/perf_counters.h
+++ b/src/common/perf_counters.h
@@ -24,21 +24,21 @@
 #include <vector>
 
 class CephContext;
-class ProfLoggerBuilder;
-class ProfLoggerCollectionTest;
+class PerfCountersBuilder;
+class PerfCountersCollectionTest;
 
 /*
- * A ProfLogger is usually associated with a single subsystem.
+ * A PerfCounters object is usually associated with a single subsystem.
  * It contains counters which we modify to track performance and throughput
  * over time. 
  *
- * ProfLogger is thread-safe. However, it is better to avoid sharing
- * ProfLoggers between multiple threads to avoid cacheline ping-pong.
+ * This object is thread-safe. However, it is better to avoid sharing
+ * a PerfCounters object between multiple threads to avoid cacheline ping-pong.
  */
-class ProfLogger
+class PerfCounters
 {
 public:
-  ~ProfLogger();
+  ~PerfCounters();
 
   void inc(int idx, uint64_t v = 1);
   void set(int idx, uint64_t v);
@@ -53,14 +53,14 @@ public:
   const std::string& get_name() const;
 
 private:
-  ProfLogger(CephContext *cct, const std::string &name,
+  PerfCounters(CephContext *cct, const std::string &name,
 	     int lower_bound, int upper_bound);
-  ProfLogger(const ProfLogger &rhs);
-  ProfLogger& operator=(const ProfLogger &rhs);
+  PerfCounters(const PerfCounters &rhs);
+  PerfCounters& operator=(const PerfCounters &rhs);
 
-  /** Represents a ProfLogger data element. */
-  struct prof_log_data_any_d {
-    prof_log_data_any_d();
+  /** Represents a PerfCounters data element. */
+  struct perf_counter_data_any_d {
+    perf_counter_data_any_d();
     const char *name;
     int type;
     union {
@@ -69,7 +69,7 @@ private:
     } u;
     uint64_t count;
   };
-  typedef std::vector<prof_log_data_any_d> prof_log_data_vec_t;
+  typedef std::vector<perf_counter_data_any_d> perf_counter_data_vec_t;
 
   CephContext *m_cct;
   int m_lower_bound;
@@ -80,30 +80,30 @@ private:
   /** Protects m_data */
   mutable Mutex m_lock;
 
-  prof_log_data_vec_t m_data;
+  perf_counter_data_vec_t m_data;
 
-  friend class ProfLoggerBuilder;
+  friend class PerfCountersBuilder;
 };
 
-class SortProfLoggersByName {
+class SortPerfCountersByName {
 public:
-  bool operator()(const ProfLogger* lhs, const ProfLogger* rhs) const {
+  bool operator()(const PerfCounters* lhs, const PerfCounters* rhs) const {
     return (lhs->get_name() < rhs->get_name());
   }
 };
 
-typedef std::set <ProfLogger*, SortProfLoggersByName> prof_logger_set_t;
+typedef std::set <PerfCounters*, SortPerfCountersByName> perf_counters_set_t;
 
 /*
- * ProfLoggerCollection manages the set of ProfLoggers for a Ceph process.
+ * PerfCountersCollection manages PerfCounters objects for a Ceph process.
  */
-class ProfLoggerCollection
+class PerfCountersCollection
 {
 public:
-  ProfLoggerCollection(CephContext *cct);
-  ~ProfLoggerCollection();
-  void logger_add(class ProfLogger *l);
-  void logger_remove(class ProfLogger *l);
+  PerfCountersCollection(CephContext *cct);
+  ~PerfCountersCollection();
+  void logger_add(class PerfCounters *l);
+  void logger_remove(class PerfCounters *l);
   void logger_clear();
   void write_json_to_buf(std::vector <char> &buffer);
 private:
@@ -116,35 +116,35 @@ private:
   mutable Mutex m_lock;
 
   int m_shutdown_fd;
-  prof_logger_set_t m_loggers;
+  perf_counters_set_t m_loggers;
 
-  friend class ProfLoggerCollectionTest;
+  friend class PerfCountersCollectionTest;
 };
 
-/* Class for constructing ProfLoggers.
+/* Class for constructing a PerfCounters object.
  *
  * This class peforms some validation that the parameters we have supplied are
- * correct in create_proflogger().
+ * correct in create_perf_counters().
  *
  * In the future, we will probably get rid of the first/last arguments, since
- * ProfLoggerBuilder can deduce them itself.
+ * PerfCountersBuilder can deduce them itself.
  */
-class ProfLoggerBuilder
+class PerfCountersBuilder
 {
 public:
-  ProfLoggerBuilder(CephContext *cct, const std::string &name,
+  PerfCountersBuilder(CephContext *cct, const std::string &name,
 		    int first, int last);
-  ~ProfLoggerBuilder();
+  ~PerfCountersBuilder();
   void add_u64(int key, const char *name);
   void add_fl(int key, const char *name);
   void add_fl_avg(int key, const char *name);
-  ProfLogger* create_proflogger();
+  PerfCounters* create_perf_counters();
 private:
-  ProfLoggerBuilder(const ProfLoggerBuilder &rhs);
-  ProfLoggerBuilder& operator=(const ProfLoggerBuilder &rhs);
+  PerfCountersBuilder(const PerfCountersBuilder &rhs);
+  PerfCountersBuilder& operator=(const PerfCountersBuilder &rhs);
   void add_impl(int idx, const char *name, int ty, uint64_t count);
 
-  ProfLogger *m_prof_logger;
+  PerfCounters *m_perf_counters;
 };
 
 #endif
diff --git a/src/mds/MDCache.h b/src/mds/MDCache.h
index 0e9f023c333..ea01991c68c 100644
--- a/src/mds/MDCache.h
+++ b/src/mds/MDCache.h
@@ -29,7 +29,7 @@
 #include "messages/MClientRequest.h"
 #include "messages/MMDSSlaveRequest.h"
 
-class ProfLogger;
+class PerfCounters;
 
 class MDS;
 class Session;
diff --git a/src/mds/MDLog.cc b/src/mds/MDLog.cc
index 4b0721e414d..8f91401be56 100644
--- a/src/mds/MDLog.cc
+++ b/src/mds/MDLog.cc
@@ -37,7 +37,7 @@ MDLog::~MDLog()
 {
   if (journaler) { delete journaler; journaler = 0; }
   if (logger) {
-    g_ceph_context->GetProfLoggerCollection()->logger_remove(logger);
+    g_ceph_context->GetPerfCountersCollection()->logger_remove(logger);
     delete logger;
     logger = 0;
   }
@@ -48,7 +48,7 @@ void MDLog::create_logger()
 {
   char name[80];
   snprintf(name, sizeof(name), "mds.%s.log", g_conf->name.get_id().c_str());
-  ProfLoggerBuilder plb(g_ceph_context, name, l_mdl_first, l_mdl_last);
+  PerfCountersBuilder plb(g_ceph_context, name, l_mdl_first, l_mdl_last);
 
   plb.add_u64(l_mdl_evadd, "evadd");
   plb.add_u64(l_mdl_evex, "evex");
@@ -70,8 +70,8 @@ void MDLog::create_logger()
   plb.add_u64(l_mdl_jlat, "jlat");
 
   // logger
-  logger = plb.create_proflogger();
-  g_ceph_context->GetProfLoggerCollection()->logger_add(logger);
+  logger = plb.create_perf_counters();
+  g_ceph_context->GetPerfCountersCollection()->logger_add(logger);
 }
 
 void MDLog::init_journaler()
diff --git a/src/mds/MDLog.h b/src/mds/MDLog.h
index ce5b4152bc4..b461f077f61 100644
--- a/src/mds/MDLog.h
+++ b/src/mds/MDLog.h
@@ -53,7 +53,7 @@ class MDS;
 class LogSegment;
 class ESubtreeMap;
 
-class ProfLogger;
+class PerfCounters;
 
 #include <map>
 using std::map;
@@ -72,7 +72,7 @@ protected:
   inodeno_t ino;
   Journaler *journaler;
 
-  ProfLogger *logger;
+  PerfCounters *logger;
 
 
   // -- replay --
diff --git a/src/mds/MDS.cc b/src/mds/MDS.cc
index 4ee04497142..65bac94506f 100644
--- a/src/mds/MDS.cc
+++ b/src/mds/MDS.cc
@@ -172,12 +172,12 @@ MDS::~MDS() {
   if (objecter) { delete objecter; objecter = 0; }
 
   if (logger) {
-    g_ceph_context->GetProfLoggerCollection()->logger_remove(logger);
+    g_ceph_context->GetPerfCountersCollection()->logger_remove(logger);
     delete logger;
     logger = 0;
   }
   if (mlogger) {
-    g_ceph_context->GetProfLoggerCollection()->logger_remove(logger);
+    g_ceph_context->GetPerfCountersCollection()->logger_remove(logger);
     delete mlogger;
     mlogger = 0;
   }
@@ -194,7 +194,7 @@ void MDS::create_logger()
     snprintf(name, sizeof(name), "mds.%s.%llu.log",
 	     g_conf->name.get_id().c_str(),
 	     (unsigned long long) monc->get_global_id());
-    ProfLoggerBuilder mds_plb(g_ceph_context, name,
+    PerfCountersBuilder mds_plb(g_ceph_context, name,
 			      l_mds_first, l_mds_last);
 
     mds_plb.add_u64(l_mds_req, "req"); // FIXME: nobody is actually setting this
@@ -252,8 +252,8 @@ void MDS::create_logger()
     mds_plb.add_u64(l_mds_iexp, "iexp");
     mds_plb.add_u64(l_mds_im, "im");
     mds_plb.add_u64(l_mds_iim, "iim");
-    logger = mds_plb.create_proflogger();
-    g_ceph_context->GetProfLoggerCollection()->logger_add(logger);
+    logger = mds_plb.create_perf_counters();
+    g_ceph_context->GetPerfCountersCollection()->logger_add(logger);
   }
 
   {
@@ -261,7 +261,7 @@ void MDS::create_logger()
     snprintf(name, sizeof(name), "mds.%s.%llu.mem.log",
 	     g_conf->name.get_id().c_str(),
 	     (unsigned long long) monc->get_global_id());
-    ProfLoggerBuilder mdm_plb(g_ceph_context, name,
+    PerfCountersBuilder mdm_plb(g_ceph_context, name,
 			      l_mdm_first, l_mdm_last);
     mdm_plb.add_u64(l_mdm_ino, "ino");
     mdm_plb.add_u64(l_mdm_inoa, "ino+");
@@ -279,8 +279,8 @@ void MDS::create_logger()
     mdm_plb.add_u64(l_mdm_heap, "heap");
     mdm_plb.add_u64(l_mdm_malloc, "malloc");
     mdm_plb.add_u64(l_mdm_buf, "buf");
-    mlogger = mdm_plb.create_proflogger();
-    g_ceph_context->GetProfLoggerCollection()->logger_add(mlogger);
+    mlogger = mdm_plb.create_perf_counters();
+    g_ceph_context->GetPerfCountersCollection()->logger_add(mlogger);
   }
 
   mdlog->create_logger();
diff --git a/src/mds/MDS.h b/src/mds/MDS.h
index d4e365cddb1..9b324b00737 100644
--- a/src/mds/MDS.h
+++ b/src/mds/MDS.h
@@ -177,7 +177,7 @@ class MDS : public Dispatcher {
   MDSTableClient *get_table_client(int t);
   MDSTableServer *get_table_server(int t);
 
-  ProfLogger       *logger, *mlogger;
+  PerfCounters       *logger, *mlogger;
 
   int orig_argc;
   const char **orig_argv;
diff --git a/src/mds/Server.cc b/src/mds/Server.cc
index 17f2533822f..79c426aaaa9 100644
--- a/src/mds/Server.cc
+++ b/src/mds/Server.cc
@@ -67,14 +67,14 @@ void Server::create_logger()
 {
   char name[80];
   snprintf(name, sizeof(name), "mds.%s.server.log", g_conf->name.get_id().c_str());
-  ProfLoggerBuilder plb(g_ceph_context, name, l_mdss_first, l_mdss_last);
+  PerfCountersBuilder plb(g_ceph_context, name, l_mdss_first, l_mdss_last);
   plb.add_u64(l_mdss_hcreq,"hcreq"); // handle client req
   plb.add_u64(l_mdss_hsreq, "hsreq"); // slave
   plb.add_u64(l_mdss_hcsess, "hcsess");    // client session
   plb.add_u64(l_mdss_dcreq, "dcreq"); // dispatch client req
   plb.add_u64(l_mdss_dsreq, "dsreq"); // slave
-  logger = plb.create_proflogger();
-  g_ceph_context->GetProfLoggerCollection()->logger_add(logger);
+  logger = plb.create_perf_counters();
+  g_ceph_context->GetPerfCountersCollection()->logger_add(logger);
 }
 
 
diff --git a/src/mds/Server.h b/src/mds/Server.h
index 793f9029546..08678d94ccc 100644
--- a/src/mds/Server.h
+++ b/src/mds/Server.h
@@ -17,7 +17,7 @@
 
 #include "MDS.h"
 
-class ProfLogger;
+class PerfCounters;
 class LogEvent;
 class MDRequest;
 class Mutation;
@@ -41,7 +41,7 @@ class Server {
   MDCache *mdcache;
   MDLog *mdlog;
   Messenger *messenger;
-  ProfLogger *logger;
+  PerfCounters *logger;
 
 public:
   int failed_reconnects;
@@ -57,7 +57,7 @@ public:
     terminating_sessions(false) {
   }
   ~Server() {
-    g_ceph_context->GetProfLoggerCollection()->logger_remove(logger);
+    g_ceph_context->GetPerfCountersCollection()->logger_remove(logger);
     delete logger;
   }
 
diff --git a/src/os/FileStore.cc b/src/os/FileStore.cc
index 50b79079eb6..2a693b9dd04 100644
--- a/src/os/FileStore.cc
+++ b/src/os/FileStore.cc
@@ -1883,7 +1883,7 @@ void FileStore::start_logger(int whoami, utime_t tare)
 
   char name[80];
   snprintf(name, sizeof(name), "osd.%d.fs.log", whoami);
-  ProfLoggerBuilder plb(g_ceph_context, name, l_os_first, l_os_last);
+  PerfCountersBuilder plb(g_ceph_context, name, l_os_first, l_os_last);
 
   plb.add_u64(l_os_in_ops, "in_o");
   //plb.add_u64(l_os_in_bytes, "in_b");
@@ -1906,10 +1906,10 @@ void FileStore::start_logger(int whoami, utime_t tare)
   plb.add_u64(l_os_bytes, "b");
   plb.add_u64(l_os_committing, "comitng");
 
-  logger = plb.create_proflogger();
+  logger = plb.create_perf_counters();
   if (journal)
     journal->logger = logger;
-  g_ceph_context->GetProfLoggerCollection()->logger_add(logger);
+  g_ceph_context->GetPerfCountersCollection()->logger_add(logger);
 }
 
 void FileStore::stop_logger()
@@ -1918,7 +1918,7 @@ void FileStore::stop_logger()
   if (logger) {
     if (journal)
       journal->logger = NULL;
-    g_ceph_context->GetProfLoggerCollection()->logger_remove(logger);
+    g_ceph_context->GetPerfCountersCollection()->logger_remove(logger);
     delete logger;
     logger = NULL;
   }
diff --git a/src/os/FileStore.h b/src/os/FileStore.h
index 260744f4a6c..0892b83abff 100644
--- a/src/os/FileStore.h
+++ b/src/os/FileStore.h
@@ -231,7 +231,7 @@ class FileStore : public JournalingObjectStore {
   int open_journal();
 
 
-  ProfLogger *logger;
+  PerfCounters *logger;
 
 public:
   void start_logger(int whoami, utime_t tare);
diff --git a/src/os/Journal.h b/src/os/Journal.h
index 7a07476ff23..48d8fe30ce6 100644
--- a/src/os/Journal.h
+++ b/src/os/Journal.h
@@ -20,14 +20,14 @@
 #include "include/Context.h"
 #include "common/Finisher.h"
 
-class ProfLogger;
+class PerfCounters;
 
 class Journal {
 protected:
   uint64_t fsid;
   Finisher *finisher;
 public:
-  ProfLogger *logger;
+  PerfCounters *logger;
 protected:
   Cond *do_sync_cond;
   bool wait_on_full;
diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc
index 4e61d0f727b..9a396d03deb 100644
--- a/src/osd/OSD.cc
+++ b/src/osd/OSD.cc
@@ -468,7 +468,7 @@ OSD::~OSD()
 {
   delete map_in_progress_cond;
   delete class_handler;
-  g_ceph_context->GetProfLoggerCollection()->logger_remove(logger);
+  g_ceph_context->GetPerfCountersCollection()->logger_remove(logger);
   delete logger;
   delete store;
 }
@@ -628,7 +628,7 @@ void OSD::create_logger()
 
   char name[80];
   snprintf(name, sizeof(name), "osd.%d.log", whoami);
-  ProfLoggerBuilder osd_plb(g_ceph_context, name, l_osd_first, l_osd_last);
+  PerfCountersBuilder osd_plb(g_ceph_context, name, l_osd_first, l_osd_last);
 
   osd_plb.add_u64(l_osd_opq, "opq");       // op queue length (waiting to be processed yet)
   osd_plb.add_u64(l_osd_op_wip, "op_wip");   // rep ops currently being processed (primary)
@@ -683,8 +683,8 @@ void OSD::create_logger()
   osd_plb.add_u64(l_osd_mape, "mape");         // osdmap epochs
   osd_plb.add_u64(l_osd_mape_dup, "mape_dup"); // dup osdmap epochs
 
-  logger = osd_plb.create_proflogger();
-  g_ceph_context->GetProfLoggerCollection()->logger_add(logger);
+  logger = osd_plb.create_perf_counters();
+  g_ceph_context->GetPerfCountersCollection()->logger_add(logger);
 }
 
 int OSD::shutdown()
diff --git a/src/osd/OSD.h b/src/osd/OSD.h
index b785d7f2c97..8a6e8a66006 100644
--- a/src/osd/OSD.h
+++ b/src/osd/OSD.h
@@ -103,7 +103,7 @@ enum {
 class Messenger;
 class Message;
 class MonClient;
-class ProfLogger;
+class PerfCounters;
 class ObjectStore;
 class OSDMap;
 class MLog;
@@ -126,7 +126,7 @@ protected:
   Messenger   *cluster_messenger;
   Messenger   *client_messenger;
   MonClient   *monc;
-  ProfLogger      *logger;
+  PerfCounters      *logger;
   ObjectStore *store;
 
   // cover OSDMap update data when using multiple msgrs
diff --git a/src/osdc/Journaler.h b/src/osdc/Journaler.h
index c601da3f0ff..cbb7319f2ab 100644
--- a/src/osdc/Journaler.h
+++ b/src/osdc/Journaler.h
@@ -58,7 +58,7 @@
 
 class CephContext;
 class Context;
-class ProfLogger;
+class PerfCounters;
 
 class Journaler {
 public:
@@ -110,7 +110,7 @@ private:
   Objecter *objecter;
   Filer filer;
 
-  ProfLogger *logger;
+  PerfCounters *logger;
   int logger_key_lat;
 
   SafeTimer *timer;
@@ -229,7 +229,7 @@ private:
   }
 
 public:
-  Journaler(inodeno_t ino_, int pool, const char *mag, Objecter *obj, ProfLogger *l, int lkey, SafeTimer *tim) : 
+  Journaler(inodeno_t ino_, int pool, const char *mag, Objecter *obj, PerfCounters *l, int lkey, SafeTimer *tim) : 
     cct(obj->cct), last_written(mag), last_committed(mag),
     ino(ino_), pg_pool(pool), readonly(true), magic(mag),
     objecter(obj), filer(objecter), logger(l), logger_key_lat(lkey),
diff --git a/src/test/perf_counters.cc b/src/test/perf_counters.cc
index 751cc0bb9b9..17ecfdfdea7 100644
--- a/src/test/perf_counters.cc
+++ b/src/test/perf_counters.cc
@@ -35,7 +35,7 @@
 #include <time.h>
 #include <unistd.h>
 
-TEST(ProfLogger, SimpleTest) {
+TEST(PerfCounters, SimpleTest) {
   g_ceph_context->_conf->set_val_or_die("admin_socket", get_rand_socket_path());
   g_ceph_context->_conf->apply_changes();
   AdminSocketClient client(get_rand_socket_path());
@@ -45,11 +45,11 @@ TEST(ProfLogger, SimpleTest) {
 }
 
 enum {
-  FAKE_PROFLOGGER1_ELEMENT_FIRST = 200,
-  FAKE_PROFLOGGER1_ELEMENT_1,
-  FAKE_PROFLOGGER1_ELEMENT_2,
-  FAKE_PROFLOGGER1_ELEMENT_3,
-  FAKE_PROFLOGGER1_ELEMENT_LAST,
+  TEST_PERFCOUNTERS1_ELEMENT_FIRST = 200,
+  TEST_PERFCOUNTERS1_ELEMENT_1,
+  TEST_PERFCOUNTERS1_ELEMENT_2,
+  TEST_PERFCOUNTERS1_ELEMENT_3,
+  TEST_PERFCOUNTERS1_ELEMENT_LAST,
 };
 
 std::string sd(const char *c)
@@ -64,61 +64,61 @@ std::string sd(const char *c)
   return ret;
 }
 
-static ProfLogger* setup_fake_proflogger1(CephContext *cct)
+static PerfCounters* setup_fake_proflogger1(CephContext *cct)
 {
-  ProfLoggerBuilder bld(cct, "fake_proflogger_1",
-	  FAKE_PROFLOGGER1_ELEMENT_FIRST, FAKE_PROFLOGGER1_ELEMENT_LAST);
-  bld.add_u64(FAKE_PROFLOGGER1_ELEMENT_1, "element1");
-  bld.add_fl(FAKE_PROFLOGGER1_ELEMENT_2, "element2");
-  bld.add_fl_avg(FAKE_PROFLOGGER1_ELEMENT_3, "element3");
-  return bld.create_proflogger();
+  PerfCountersBuilder bld(cct, "test_perfcounter_1",
+	  TEST_PERFCOUNTERS1_ELEMENT_FIRST, TEST_PERFCOUNTERS1_ELEMENT_LAST);
+  bld.add_u64(TEST_PERFCOUNTERS1_ELEMENT_1, "element1");
+  bld.add_fl(TEST_PERFCOUNTERS1_ELEMENT_2, "element2");
+  bld.add_fl_avg(TEST_PERFCOUNTERS1_ELEMENT_3, "element3");
+  return bld.create_perf_counters();
 }
 
-TEST(ProfLogger, SingleProfLogger) {
-  ProfLoggerCollection *coll = g_ceph_context->GetProfLoggerCollection();
-  ProfLogger* fake_pf = setup_fake_proflogger1(g_ceph_context);
+TEST(PerfCounters, SingleProfLogger) {
+  PerfCountersCollection *coll = g_ceph_context->GetPerfCountersCollection();
+  PerfCounters* fake_pf = setup_fake_proflogger1(g_ceph_context);
   coll->logger_add(fake_pf);
   g_ceph_context->_conf->set_val_or_die("admin_socket", get_rand_socket_path());
   g_ceph_context->_conf->apply_changes();
   AdminSocketClient client(get_rand_socket_path());
   std::string msg;
   ASSERT_EQ("", client.get_message(&msg));
-  ASSERT_EQ(sd("{'fake_proflogger_1':{'element1':0,"
+  ASSERT_EQ(sd("{'test_perfcounter_1':{'element1':0,"
 	    "'element2':0,'element3':{'count':0,'sum':0},},}"), msg);
-  fake_pf->inc(FAKE_PROFLOGGER1_ELEMENT_1);
-  fake_pf->fset(FAKE_PROFLOGGER1_ELEMENT_2, 0.5);
-  fake_pf->finc(FAKE_PROFLOGGER1_ELEMENT_3, 100.0);
+  fake_pf->inc(TEST_PERFCOUNTERS1_ELEMENT_1);
+  fake_pf->fset(TEST_PERFCOUNTERS1_ELEMENT_2, 0.5);
+  fake_pf->finc(TEST_PERFCOUNTERS1_ELEMENT_3, 100.0);
   ASSERT_EQ("", client.get_message(&msg));
-  ASSERT_EQ(sd("{'fake_proflogger_1':{'element1':1,"
+  ASSERT_EQ(sd("{'test_perfcounter_1':{'element1':1,"
 	    "'element2':0.5,'element3':{'count':1,'sum':100},},}"), msg);
-  fake_pf->finc(FAKE_PROFLOGGER1_ELEMENT_3, 0.0);
-  fake_pf->finc(FAKE_PROFLOGGER1_ELEMENT_3, 25.0);
+  fake_pf->finc(TEST_PERFCOUNTERS1_ELEMENT_3, 0.0);
+  fake_pf->finc(TEST_PERFCOUNTERS1_ELEMENT_3, 25.0);
   ASSERT_EQ("", client.get_message(&msg));
-  ASSERT_EQ(sd("{'fake_proflogger_1':{'element1':1,'element2':0.5,"
+  ASSERT_EQ(sd("{'test_perfcounter_1':{'element1':1,'element2':0.5,"
 	    "'element3':{'count':3,'sum':125},},}"), msg);
 }
 
 enum {
-  FAKE_PROFLOGGER2_ELEMENT_FIRST = 400,
-  FAKE_PROFLOGGER2_ELEMENT_FOO,
-  FAKE_PROFLOGGER2_ELEMENT_BAR,
-  FAKE_PROFLOGGER2_ELEMENT_LAST,
+  TEST_PERFCOUNTERS2_ELEMENT_FIRST = 400,
+  TEST_PERFCOUNTERS2_ELEMENT_FOO,
+  TEST_PERFCOUNTERS2_ELEMENT_BAR,
+  TEST_PERFCOUNTERS2_ELEMENT_LAST,
 };
 
-static ProfLogger* setup_fake_proflogger2(CephContext *cct)
+static PerfCounters* setup_fake_proflogger2(CephContext *cct)
 {
-  ProfLoggerBuilder bld(cct, "fake_proflogger_2",
-	  FAKE_PROFLOGGER2_ELEMENT_FIRST, FAKE_PROFLOGGER2_ELEMENT_LAST);
-  bld.add_u64(FAKE_PROFLOGGER2_ELEMENT_FOO, "foo");
-  bld.add_fl(FAKE_PROFLOGGER2_ELEMENT_BAR, "bar");
-  return bld.create_proflogger();
+  PerfCountersBuilder bld(cct, "test_perfcounter_2",
+	  TEST_PERFCOUNTERS2_ELEMENT_FIRST, TEST_PERFCOUNTERS2_ELEMENT_LAST);
+  bld.add_u64(TEST_PERFCOUNTERS2_ELEMENT_FOO, "foo");
+  bld.add_fl(TEST_PERFCOUNTERS2_ELEMENT_BAR, "bar");
+  return bld.create_perf_counters();
 }
 
-TEST(ProfLogger, MultipleProfloggers) {
-  ProfLoggerCollection *coll = g_ceph_context->GetProfLoggerCollection();
+TEST(PerfCounters, MultipleProfloggers) {
+  PerfCountersCollection *coll = g_ceph_context->GetPerfCountersCollection();
   coll->logger_clear();
-  ProfLogger* fake_pf1 = setup_fake_proflogger1(g_ceph_context);
-  ProfLogger* fake_pf2 = setup_fake_proflogger2(g_ceph_context);
+  PerfCounters* fake_pf1 = setup_fake_proflogger1(g_ceph_context);
+  PerfCounters* fake_pf2 = setup_fake_proflogger2(g_ceph_context);
   coll->logger_add(fake_pf1);
   coll->logger_add(fake_pf2);
   g_ceph_context->_conf->set_val_or_die("admin_socket", get_rand_socket_path());
@@ -127,18 +127,18 @@ TEST(ProfLogger, MultipleProfloggers) {
   std::string msg;
 
   ASSERT_EQ("", client.get_message(&msg));
-  ASSERT_EQ(sd("{'fake_proflogger_1':{'element1':0,'element2':0,'element3':"
-	    "{'count':0,'sum':0},},'fake_proflogger_2':{'foo':0,'bar':0,},}"), msg);
+  ASSERT_EQ(sd("{'test_perfcounter_1':{'element1':0,'element2':0,'element3':"
+	    "{'count':0,'sum':0},},'test_perfcounter_2':{'foo':0,'bar':0,},}"), msg);
 
-  fake_pf1->inc(FAKE_PROFLOGGER1_ELEMENT_1);
-  fake_pf1->inc(FAKE_PROFLOGGER1_ELEMENT_1, 5);
+  fake_pf1->inc(TEST_PERFCOUNTERS1_ELEMENT_1);
+  fake_pf1->inc(TEST_PERFCOUNTERS1_ELEMENT_1, 5);
   ASSERT_EQ("", client.get_message(&msg));
-  ASSERT_EQ(sd("{'fake_proflogger_1':{'element1':6,'element2':0,'element3':"
-	    "{'count':0,'sum':0},},'fake_proflogger_2':{'foo':0,'bar':0,},}"), msg);
+  ASSERT_EQ(sd("{'test_perfcounter_1':{'element1':6,'element2':0,'element3':"
+	    "{'count':0,'sum':0},},'test_perfcounter_2':{'foo':0,'bar':0,},}"), msg);
 
   coll->logger_remove(fake_pf2);
   ASSERT_EQ("", client.get_message(&msg));
-  ASSERT_EQ(sd("{'fake_proflogger_1':{'element1':6,'element2':0,"
+  ASSERT_EQ(sd("{'test_perfcounter_1':{'element1':6,'element2':0,"
 	    "'element3':{'count':0,'sum':0},},}"), msg);
 
   coll->logger_clear();