metrics.h

Go to the documentation of this file.

// Copyright 2012 Cloudera Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef IMPALA_UTIL_METRICS_H
#define IMPALA_UTIL_METRICS_H

#include <map>
#include <string>
#include <sstream>
#include <stack>
#include <boost/foreach.hpp>
#include <boost/function.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/thread/locks.hpp>
#include <boost/thread/mutex.hpp>

#include "common/logging.h"
#include "common/status.h"
#include "common/object-pool.h"
#include "util/debug-util.h"
#include "util/json-util.h"
#include "util/pretty-printer.h"
#include "util/webserver.h"

namespace impala {

//
//
//
class Metric {
 public:
  virtual ~Metric() {}

  //
  virtual void ToJson(rapidjson::Document* document, rapidjson::Value* val) = 0;

  //
  virtual void ToLegacyJson(rapidjson::Document* document) = 0;

  virtual std::string ToHumanReadable() = 0;

  const std::string& key() const { return key_; }
  const std::string& description() const { return description_; }

 protected:
  const std::string key_;

  const std::string description_;

  friend class MetricGroup;

  Metric(const std::string& key, const std::string& description) :
      key_(key), description_(description) { }

  void AddStandardFields(rapidjson::Document* document, rapidjson::Value* val);
};

//
//
template<typename T, TMetricKind::type metric_kind=TMetricKind::GAUGE>
class SimpleMetric : public Metric {
 public:
  SimpleMetric(const std::string& key, const TUnit::type unit,
      const T& initial_value, const std::string& description = "")
      : Metric(key, description), unit_(unit), value_(initial_value)
  { }

  SimpleMetric(const std::string& key, const TUnit::type unit,
      const std::string& description = "")
      : Metric(key, description), unit_(unit) { }

  virtual ~SimpleMetric() { }

  T value() {
    boost::lock_guard<boost::mutex> l(lock_);
    CalculateValue();
    return value_;
  }

  void set_value(const T& value) {
    boost::lock_guard<boost::mutex> l(lock_);
    value_ = value;
  }

  void Increment(const T& delta) {
    DCHECK(kind() != TMetricKind::PROPERTY)
        << "Can't change value of PROPERTY metric: " << key();
    DCHECK(kind() != TMetricKind::COUNTER || delta >= 0)
        << "Can't decrement value of COUNTER metric: " << key();
    boost::lock_guard<boost::mutex> l(lock_);
    value_ += delta;
  }

  virtual void ToJson(rapidjson::Document* document, rapidjson::Value* val) {
    rapidjson::Value container(rapidjson::kObjectType);
    AddStandardFields(document, &container);

    rapidjson::Value metric_value;
    ToJsonValue(value(), TUnit::NONE, document, &metric_value);
    container.AddMember("value", metric_value, document->GetAllocator());

    rapidjson::Value type_value(PrintTMetricKind(kind()).c_str(),
        document->GetAllocator());
    container.AddMember("kind", type_value, document->GetAllocator());
    rapidjson::Value units(PrintTUnit(unit()).c_str(), document->GetAllocator());
    container.AddMember("units", units, document->GetAllocator());
    *val = container;
  }

  virtual std::string ToHumanReadable() {
    return PrettyPrinter::Print(value(), unit());
  }

  virtual void ToLegacyJson(rapidjson::Document* document) {
    rapidjson::Value val;
    ToJsonValue(value(), TUnit::NONE, document, &val);
    document->AddMember(key_.c_str(), val, document->GetAllocator());
  }

  const TUnit::type unit() const { return unit_; }
  const TMetricKind::type kind() const { return metric_kind; }

 protected:
  //
  virtual void CalculateValue() { }

  const TUnit::type unit_;

  boost::mutex lock_;

  T value_;
};

//
//
//
class MetricGroup {
 public:
  MetricGroup(const std::string& name);

  //
  template <typename M>
  M* RegisterMetric(M* metric) {
    boost::lock_guard<boost::mutex> l(lock_);
    DCHECK(!metric->key_.empty());
    DCHECK(metric_map_.find(metric->key_) == metric_map_.end());

    M* mt = obj_pool_->Add(metric);
    metric_map_[metric->key_] = mt;
    return mt;
  }

  template<typename T>
  SimpleMetric<T>* AddGauge(const std::string& key,
      const T& value, const TUnit::type unit = TUnit::NONE,
      const std::string& description = "") {
    return RegisterMetric(new SimpleMetric<T, TMetricKind::GAUGE>
        (key, unit, value, description));
  }

  template<typename T>
  SimpleMetric<T, TMetricKind::PROPERTY>* AddProperty(
      const std::string& key, const T& value,
      const std::string& description = "") {
    return RegisterMetric(new SimpleMetric<T, TMetricKind::PROPERTY> (key,
        TUnit::NONE, value, description));
  }

  template<typename T>
  SimpleMetric<T, TMetricKind::COUNTER>* AddCounter(const std::string& key,
      const T& value, const TUnit::type unit = TUnit::UNIT,
      const std::string& description = "") {
    return RegisterMetric(
        new SimpleMetric<T, TMetricKind::COUNTER>(key, unit, value, description));
  }

  //
  template <typename M>
  M* FindMetricForTesting(const std::string& key) {
    boost::lock_guard<boost::mutex> l(lock_);
    std::stack<MetricGroup*> groups;
    groups.push(this);
    while (!groups.empty()) {
      MetricGroup* group = groups.top();
      groups.pop();
      MetricMap::const_iterator it = group->metric_map_.find(key);
      if (it != group->metric_map_.end()) return reinterpret_cast<M*>(it->second);
      BOOST_FOREACH(const ChildGroupMap::value_type& child, group->children_) {
        groups.push(child.second);
      }
    }
    return NULL;
  }

  Status Init(Webserver* webserver);

  void ToJson(bool include_children, rapidjson::Document* document,
      rapidjson::Value* out_val);

  MetricGroup* GetChildGroup(const std::string& name);

  std::string DebugString();

  const std::string& name() const { return name_; }

 private:
  boost::scoped_ptr<ObjectPool> obj_pool_;

  std::string name_;

  boost::mutex lock_;

  typedef std::map<std::string, Metric*> MetricMap;
  MetricMap metric_map_;

  typedef std::map<std::string, MetricGroup*> ChildGroupMap;
  ChildGroupMap children_;

  void TemplateCallback(const Webserver::ArgumentMap& args,
      rapidjson::Document* document);

  void CMCompatibleCallback(const Webserver::ArgumentMap& args,
      rapidjson::Document* document);
};

typedef class SimpleMetric<int64_t, TMetricKind::GAUGE> IntGauge;
typedef class SimpleMetric<uint64_t, TMetricKind::GAUGE> UIntGauge;
typedef class SimpleMetric<double, TMetricKind::GAUGE> DoubleGauge;
typedef class SimpleMetric<int64_t, TMetricKind::COUNTER> IntCounter;

typedef class SimpleMetric<bool, TMetricKind::PROPERTY> BooleanProperty;
typedef class SimpleMetric<std::string, TMetricKind::PROPERTY> StringProperty;

}

#endif // IMPALA_UTIL_METRICS_H