YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements.  See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership.  The ASF licenses this file

// to you 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.

//

// The following only applies to changes made to this file as part of YugaByte development.

//

// Portions Copyright (c) YugaByte, 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 YB_UTIL_METRICS_H

#define YB_UTIL_METRICS_H

/////////////////////////////////////////////////////

// YB Metrics

/////////////////////////////////////////////////////

//

// Summary

// ------------------------------------------------------------

//

// This API provides a basic set of metrics primitives along the lines of the Coda Hale's

// metrics library along with JSON formatted output of running metrics.

//

// The metrics system has a few main concepts in its data model:

//

// Metric Prototypes

// -----------------

// Every metric that may be emitted is constructed from a prototype. The prototype defines

// the name of the metric, the entity it is attached to, its type, its units, and a description.

//

// Metric prototypes are defined statically using the METRIC_DEFINE_*(...) macros. This

// allows us to easily enumerate a full list of every metric that might be emitted from a

// server, thus allowing auto-generation of metric metadata for integration with

// monitoring systems such as Prometheus.

//

// Metric Entity Prototypes

// ------------------------

// The other main type in the data model is the Metric Entity. The most basic entity is the

// "server" entity -- metrics such as memory usage, RPC rates, etc, are typically associated

// with the server as a whole.

//

// Users of the metrics framework can define more entity types using the

// METRIC_DEFINE_entity(...) macro.

//

// MetricEntity instances

// -----------------------

// Each defined Metric Entity Type serves as a prototype allowing instantiation of a

// MetricEntity object. Each instance then has its own unique set of metrics. For

// example, we define a Metric Entity Type called 'tablet', and the

// Tablet Server instantiates one MetricEntity instance per tablet that it hosts.

//

// MetricEntity instances are instantiated within a MetricRegistry, and each instance is

// expected to have a unique string identifier within that registry. To continue the

// example above, a tablet entity uses its tablet ID as its unique identifier. These

// identifiers are exposed to the operator and surfaced in monitoring tools.

//

// MetricEntity instances may also carry a key-value map of string attributes. These

// attributes are directly exposed to monitoring systems via the JSON output. Monitoring

// systems may use this information to allow hierarchical aggregation beteween entities,

// display them to the user, etc.

//

// Metric instances

// ----------------

// Given a MetricEntity instance and a Metric Prototype, one can instantiate a Metric

// instance. For example, the YB Tablet Server instantiates one MetricEntity instance

// for each tablet, and then instantiates the 'tablet_rows_inserted' prototype within that

// entity. Thus, each tablet then has a separate instance of the metric, allowing the end

// operator to track the metric on a per-tablet basis.

//

//

// Types of metrics

// ------------------------------------------------------------

// Gauge: Set or get a point-in-time value.

//  - string: Gauge for a string value.

//  - Primitive types (bool, int64_t/uint64_t, double): Lock-free gauges.

// Counter: Get, reset, increment or decrement an int64_t value.

// Histogram: Increment buckets of values segmented by configurable max and precision.

//

// Gauge vs. Counter

// ------------------------------------------------------------

//

// A Counter is a metric we expect to only monotonically increase. A

// Gauge is a metric that can decrease and increase. Use a Gauge to

// reflect a sample, e.g., the number of transaction in-flight at a

// given time; use a Counter when considering a metric over time,

// e.g., exposing the number of transactions processed since start to

// produce a metric for the number of transactions processed over some

// time period.

//

// The one exception to this rule is that occasionally it may be more convenient to

// implement a metric as a Gauge, even when it is logically a counter, due to Gauge's

// support for fetching metric values via a bound function. In that case, you can

// use the 'EXPOSE_AS_COUNTER' flag when defining the gauge prototype. For example:

//

// METRIC_DEFINE_gauge_uint64(server, threads_started,

//                            "Threads Started",

//                            yb::MetricUnit::kThreads,

//                            "Total number of threads started on this server",

//                            yb::EXPOSE_AS_COUNTER);

//

//

// Metrics ownership

// ------------------------------------------------------------

//

// Metrics are reference-counted, and one of the references is always held by a metrics

// entity itself. Users of metrics should typically hold a scoped_refptr to their metrics

// within class instances, so that they also hold a reference. The one exception to this

// is FunctionGauges: see the class documentation below for a typical Gauge ownership pattern.

//

// Because the metrics entity holds a reference to the metric, this means that metrics will

// not be immediately destructed when your class instance publishing them is destructed.

// This is on purpose: metrics are retained for a configurable time interval even after they

// are no longer being published. The purpose of this is to allow monitoring systems, which

// only poll metrics infrequently (eg once a minute) to see the last value of a metric whose

// owner was destructed in between two polls.

//

//

// Example usage for server-level metrics

// ------------------------------------------------------------

//

// 1) In your server class, define the top-level registry and the server entity:

//

//   MetricRegistry metric_registry_;

//   scoped_refptr<MetricEntity> metric_entity_;

//

// 2) In your server constructor/initialization, construct metric_entity_. This instance

//    will be plumbed through into other subsystems that want to register server-level

//    metrics.

//

//   metric_entity_ = METRIC_ENTITY_server.Instantiate(&registry_, "some server identifier)");

//

// 3) At the top of your .cc file where you want to emit a metric, define the metric prototype:

//

//   METRIC_DEFINE_counter(server, ping_requests, "Ping Requests", yb::MetricUnit::kRequests,

//       "Number of Ping() RPC requests this server has handled since start");

//

// 4) In your class where you want to emit metrics, define the metric instance itself:

//   scoped_refptr<Counter> ping_counter_;

//

// 5) In your class constructor, instantiate the metric based on the MetricEntity plumbed in:

//

//   MyClass(..., const scoped_refptr<MetricEntity>& metric_entity) :

//     ping_counter_(METRIC_ping_requests.Instantiate(metric_entity)) {

//   }

//

// 6) Where you want to change the metric value, just use the instance variable:

//

//   ping_counter_->IncrementBy(100);

//

//

// Example usage for custom entity metrics

// ------------------------------------------------------------

// Follow the same pattern as above, but also define a metric entity somewhere. For example:

//

// At the top of your CC file:

//

//   METRIC_DEFINE_entity(my_entity);

//   METRIC_DEFINE_counter(my_entity, ping_requests, "Ping Requests", yb::MetricUnit::kRequests,

//       "Number of Ping() RPC requests this particular entity has handled since start");

//

// In whatever class represents the entity:

//

//   entity_ = METRIC_ENTITY_my_entity.Instantiate(&registry_, my_entity_id);

//

// In whatever classes emit metrics:

//

//   scoped_refptr<Counter> ping_requests_ = METRIC_ping_requests.Instantiate(entity);

//   ping_requests_->Increment();

//

// NOTE: at runtime, the metrics system prevents you from instantiating a metric in the

// wrong entity type. This ensures that the metadata can fully describe the set of metric-entity

// relationships.

//

// Plumbing of MetricEntity and MetricRegistry objects

// ------------------------------------------------------------

// Generally, the rule of thumb to follow when plumbing through entities and registries is

// this: if you're creating new entities or you need to dump the registry contents

// (e.g. path handlers), pass in the registry. Otherwise, pass in the entity.

//

// ===========

// JSON output

// ===========

//

// The first-class output format for metrics is pretty-printed JSON.

// Such a format is relatively easy for humans and machines to read.

//

// The top level JSON object is an array, which contains one element per

// entity. Each entity is an object which has its type, id, and an array

// of metrics. Each metric contains its type, name, unit, description, value,

// etc.

// TODO: Output to HTML.

//

// Example JSON output:

//

// [

//     {

//         "type": "tablet",

//         "id": "e95e57ba8d4d48458e7c7d35020d4a46",

//         "attributes": {

//           "table_id": "12345",

//           "table_name": "my_table"

//         },

//         "metrics": [

//             {

//                 "type": "counter",

//                 "name": "log_reader_bytes_read",

//                 "label": "Log Reader Bytes Read",

//                 "unit": "bytes",

//                 "description": "Number of bytes read since tablet start",

//                 "value": 0

//             },

//             ...

//           ]

//      },

//      ...

// ]

//

/////////////////////////////////////////////////////

#include <stdint.h>

#include <cstdint>

#include <cstdlib>

#include <set>

#include <string>

#include <boost/preprocessor/cat.hpp>

#include <boost/preprocessor/stringize.hpp>

#include <gflags/gflags_declare.h>

#include <gtest/gtest_prod.h>

#include "yb/gutil/casts.h"

#include "yb/gutil/integral_types.h"

#include "yb/util/metrics_fwd.h"

#include "yb/util/status_fwd.h"

#include "yb/util/atomic.h"

#include "yb/util/jsonwriter.h"

#include "yb/util/metrics_writer.h"

#include "yb/util/monotime.h"

#include "yb/util/shared_lock.h"

#include "yb/util/striped64.h"

// Define a new entity type.

//

// The metrics subsystem itself defines the entity type 'server', but other

// entity types can be registered using this macro.

#define METRIC_DEFINE_entity(name)                               \

  ::yb::MetricEntityPrototype METRIC_ENTITY_##name(#name)

// Convenience macros to define metric prototypes.

// See the documentation at the top of this file for example usage.

#define METRIC_DEFINE_counter_with_level(entity, name, label, unit, desc, level)   \

  ::yb::CounterPrototype BOOST_PP_CAT(METRIC_, name)(                        \

      ::yb::MetricPrototype::CtorArgs(BOOST_PP_STRINGIZE(entity), \

                                      BOOST_PP_STRINGIZE(name), \

                                      label, \

                                      unit, \

                                      desc, \

                                      level))

#define METRIC_DEFINE_counter(entity, name, label, unit, desc)   \

  METRIC_DEFINE_counter_with_level(entity, name, label, unit, desc, yb::MetricLevel::kInfo)

#define METRIC_DEFINE_simple_counter(entity, name, label, unit) \

    METRIC_DEFINE_counter(entity, name, label, unit, label)

#define METRIC_DEFINE_lag_with_level(entity, name, label, desc, level, ...) \

  ::yb::MillisLagPrototype BOOST_PP_CAT(METRIC_, name)( \

      ::yb::MetricPrototype::CtorArgs(BOOST_PP_STRINGIZE(entity), \

                                      BOOST_PP_STRINGIZE(name), \

                                      label, \

                                      yb::MetricUnit::kMilliseconds, \

                                      desc, \

                                      level, \

                                      ## __VA_ARGS__))

#define METRIC_DEFINE_lag(entity, name, label, desc, ...) \

  METRIC_DEFINE_lag_with_level(entity, name, label, desc, yb::MetricLevel::kInfo, ## __VA_ARGS__)

#define METRIC_DEFINE_gauge(type, entity, name, label, unit, desc, level, ...) \

  ::yb::GaugePrototype<type> BOOST_PP_CAT(METRIC_, name)(         \

      ::yb::MetricPrototype::CtorArgs(BOOST_PP_STRINGIZE(entity), \

                                      BOOST_PP_STRINGIZE(name), \

                                      label, \

                                      unit, \

                                      desc, \

                                      level, \

                                      ## __VA_ARGS__))

#define METRIC_DEFINE_gauge_string(entity, name, label, unit, desc, ...) \

    METRIC_DEFINE_gauge(std::string, entity, name, label, unit, desc, \

        yb::MetricLevel::kInfo, ## __VA_ARGS__)

#define METRIC_DEFINE_gauge_bool(entity, name, label, unit, desc, ...) \

    METRIC_DEFINE_gauge(bool, entity, name, label, unit, desc, \

        yb::MetricLevel::kInfo, ## __VA_ARGS__)

#define METRIC_DEFINE_gauge_int32(entity, name, label, unit, desc, ...) \

    METRIC_DEFINE_gauge(int32_t, entity, name, label, unit, desc, \

        yb::MetricLevel::kInfo, ## __VA_ARGS__)

#define METRIC_DEFINE_gauge_uint32(entity, name, label, unit, desc, ...) \

    METRIC_DEFINE_gauge(uint32_t, entity, name, label, unit, desc, \

        yb::MetricLevel::kInfo, ## __VA_ARGS__)

#define METRIC_DEFINE_gauge_int64(entity, name, label, unit, desc, ...) \

    METRIC_DEFINE_gauge(int64, entity, name, label, unit, desc, \

        yb::MetricLevel::kInfo, ## __VA_ARGS__)

#define METRIC_DEFINE_gauge_uint64(entity, name, label, unit, desc, ...) \

    METRIC_DEFINE_gauge(uint64_t, entity, name, label, unit, desc, \

        yb::MetricLevel::kInfo, ## __VA_ARGS__)

#define METRIC_DEFINE_simple_gauge_uint64(entity, name, label, unit, ...) \

    METRIC_DEFINE_gauge(uint64_t, entity, name, label, unit, label, \

        yb::MetricLevel::kInfo, ## __VA_ARGS__)

#define METRIC_DEFINE_gauge_double(entity, name, label, unit, desc, ...) \

    METRIC_DEFINE_gauge(double, entity, name, label, unit, desc, \

        yb::MetricLevel::kInfo, ## __VA_ARGS__)

#define METRIC_DEFINE_histogram_with_percentiles(                              \

    entity, name, label, unit, desc, max_val, num_sig_digits)                  \

  ::yb::HistogramPrototype BOOST_PP_CAT(METRIC_, name)(                        \

      ::yb::MetricPrototype::CtorArgs(BOOST_PP_STRINGIZE(entity),              \

                                      BOOST_PP_STRINGIZE(name), label, unit,   \

                                      desc,                                    \

                                      yb::MetricLevel::kInfo),                 \

      max_val, num_sig_digits, yb::ExportPercentiles::kTrue)

#define METRIC_DEFINE_coarse_histogram(entity, name, label, unit, desc)        \

  ::yb::HistogramPrototype BOOST_PP_CAT(METRIC_, name)(                        \

      ::yb::MetricPrototype::CtorArgs(BOOST_PP_STRINGIZE(entity),              \

                                      BOOST_PP_STRINGIZE(name), label, unit,   \

                                      desc,                                    \

                                      yb::MetricLevel::kInfo),                 \

      2, 1, yb::ExportPercentiles::kFalse)

// The following macros act as forward declarations for entity types and metric prototypes.

#define METRIC_DECLARE_entity(name) \

  extern ::yb::MetricEntityPrototype METRIC_ENTITY_##name

#define METRIC_DECLARE_counter(name)                             \

  extern ::yb::CounterPrototype METRIC_##name

#define METRIC_DECLARE_lag(name) \

  extern ::yb::LagPrototype METRIC_##name

#define METRIC_DECLARE_gauge_string(name) \

  extern ::yb::GaugePrototype<std::string> METRIC_##name

#define METRIC_DECLARE_gauge_bool(name) \

  extern ::yb::GaugePrototype<bool> METRIC_##name

#define METRIC_DECLARE_gauge_int32(name) \

  extern ::yb::GaugePrototype<int32_t> METRIC_##name

#define METRIC_DECLARE_gauge_uint32(name) \

  extern ::yb::GaugePrototype<uint32_t> METRIC_##name

#define METRIC_DECLARE_gauge_int64(name) \

  extern ::yb::GaugePrototype<int64_t> METRIC_##name

#define METRIC_DECLARE_gauge_uint64(name) \

  extern ::yb::GaugePrototype<uint64_t> METRIC_##name

#define METRIC_DECLARE_gauge_double(name) \

  extern ::yb::GaugePrototype<double> METRIC_##name

#define METRIC_DECLARE_histogram(name) \

  extern ::yb::HistogramPrototype METRIC_##name

#if defined(__APPLE__)

#define METRIC_DEFINE_gauge_size(entity, name, label, unit, desc, ...) \

  ::yb::GaugePrototype<size_t> METRIC_##name(                    \

      ::yb::MetricPrototype::CtorArgs(#entity, #name, label, unit, desc, ## __VA_ARGS__))

#define METRIC_DECLARE_gauge_size(name) \

  extern ::yb::GaugePrototype<size_t> METRIC_##name

#else

#define METRIC_DEFINE_gauge_size METRIC_DEFINE_gauge_uint64

#define METRIC_DECLARE_gauge_size METRIC_DECLARE_gauge_uint64

#endif

// Forward-declare the generic 'server' entity type.

// We have to do this here below the forward declarations, but not

// in the yb namespace.

METRIC_DECLARE_entity(server);

namespace yb {

class JsonWriter;

// Unit types to be used with metrics.

// As additional units are required, add them to this enum and also to Name().

struct MetricUnit {

  enum Type {

    kCacheHits,

    kCacheQueries,

    kBytes,

    kRequests,

    kEntries,

    kRows,

    kCells,

    kConnections,

    kOperations,

    kProbes,

    kNanoseconds,

    kMicroseconds,

    kMilliseconds,

    kSeconds,

    kThreads,

    kTransactions,

    kUnits,

    kMaintenanceOperations,

    kBlocks,

    kLogBlockContainers,

    kTasks,

    kMessages,

    kContextSwitches,

    kFiles,

  };

  static const char* Name(Type unit);

};

class MetricType {

 public:

  enum Type { kGauge, kCounter, kHistogram, kLag };

  static const char* Name(Type t);

 private:

  static const char* const kGaugeType;

  static const char* const kCounterType;

  static const char* const kHistogramType;

};

// Base class to allow for putting all metrics into a single container.

// See documentation at the top of this file for information on metrics ownership.

class Metric : public RefCountedThreadSafe<Metric> {

 public:

  // All metrics must be able to render themselves as JSON.

  virtual CHECKED_STATUS WriteAsJson(JsonWriter* writer,

                                     const MetricJsonOptions& opts) const = 0;

  virtual CHECKED_STATUS WriteForPrometheus(

      PrometheusWriter* writer, const MetricEntity::AttributeMap& attr,

      const MetricPrometheusOptions& opts) const = 0;

  const MetricPrototype* prototype() const { return prototype_; }

 protected:

  explicit Metric(const MetricPrototype* prototype);

  explicit Metric(std::unique_ptr<MetricPrototype> prototype);

  virtual ~Metric();

  std::unique_ptr<MetricPrototype> prototype_holder_;

  const MetricPrototype* const prototype_;

 private:

  friend class MetricEntity;

  friend class RefCountedThreadSafe<Metric>;

  // The time at which we should retire this metric if it is still un-referenced outside

  // of the metrics subsystem. If this metric is not due for retirement, this member is

  // uninitialized.

  MonoTime retire_time_;

  DISALLOW_COPY_AND_ASSIGN(Metric);

};

using MetricPtr = scoped_refptr<Metric>;

// Registry of all the metrics for a server.

//

// This aggregates the MetricEntity objects associated with the server.

class MetricRegistry {

 public:

  MetricRegistry();

  ~MetricRegistry();

  scoped_refptr<MetricEntity> FindOrCreateEntity(const MetricEntityPrototype* prototype,

                                                 const std::string& id,

                                                 const MetricEntity::AttributeMap& initial_attrs);

  // Writes metrics in this registry to 'writer'.

  //

  // 'requested_metrics' is a set of substrings to match metric names against,

  // where '*' matches all metrics.

  //

  // The string matching can either match an entity ID or a metric name.

  // If it matches an entity ID, then all metrics for that entity will be printed.

  //

  // See the MetricJsonOptions struct definition above for options changing the

  // output of this function.

  CHECKED_STATUS WriteAsJson(JsonWriter* writer,

                     const std::vector<std::string>& requested_metrics,

                     const MetricJsonOptions& opts) const;

  // Writes metrics in this registry to 'writer'.

  //

  // See the MetricPrometheusOptions struct definition above for options changing the

  // output of this function.

  CHECKED_STATUS WriteForPrometheus(PrometheusWriter* writer,

                     const MetricPrometheusOptions& opts) const;

  // Writes metrics in this registry to 'writer'.

  //

  // 'requested_metrics' is a set of substrings to match metric names against,

  // where '*' matches all metrics.

  //

  // The string matching can either match an entity ID or a metric name.

  // If it matches an entity ID, then all metrics for that entity will be printed.

  //

  // See the MetricPrometheusOptions struct definition above for options changing the

  // output of this function.

  CHECKED_STATUS WriteForPrometheus(PrometheusWriter* writer,

                     const std::vector<std::string>& requested_metrics,

                     const MetricPrometheusOptions& opts) const;

  // For each registered entity, retires orphaned metrics. If an entity has no more

  // metrics and there are no external references, entities are removed as well.

  //

  // See MetricEntity::RetireOldMetrics().

  void RetireOldMetrics();

  // Return the number of entities in this registry.

  size_t num_entities() const {

    std::lock_guard<simple_spinlock> l(lock_);

    return entities_.size();

  }

  void tablets_shutdown_insert(std::string id) {

    std::lock_guard<std::shared_timed_mutex> l(tablets_shutdown_lock_);

    tablets_shutdown_.insert(id);

  }

  void tablets_shutdown_erase(std::string id) {

    std::lock_guard<std::shared_timed_mutex> l(tablets_shutdown_lock_);

    (void)tablets_shutdown_.erase(id);

  }

  bool tablets_shutdown_find(std::string id) const {

    SharedLock<std::shared_timed_mutex> l(tablets_shutdown_lock_);

    return tablets_shutdown_.find(id) != tablets_shutdown_.end();

  }

 private:

  typedef std::unordered_map<std::string, scoped_refptr<MetricEntity> > EntityMap;

  EntityMap entities_;

  mutable std::shared_timed_mutex tablets_shutdown_lock_;

  // Set of tablets that have been shutdown. Protected by tablets_shutdown_lock_.

  std::set<std::string> tablets_shutdown_;

  // Returns whether a tablet has been shutdown.

  bool TabletHasBeenShutdown(const scoped_refptr<MetricEntity> entity) const;

  mutable simple_spinlock lock_;

  DISALLOW_COPY_AND_ASSIGN(MetricRegistry);

};

enum PrototypeFlags {

  // Flag which causes a Gauge prototype to expose itself as if it

  // were a counter.

  EXPOSE_AS_COUNTER = 1 << 0

};

class MetricPrototype {

 public:

  struct OptionalArgs {

    OptionalArgs(uint32_t flags = 0,

                 AggregationFunction aggregation_function = AggregationFunction::kSum)

      : flags_(flags),

        aggregation_function_(aggregation_function) {

    }

    const uint32_t flags_;

    const AggregationFunction aggregation_function_;

  };

  // Simple struct to aggregate the arguments common to all prototypes.

  // This makes constructor chaining a little less tedious.

  struct CtorArgs {

    CtorArgs(const char* entity_type,

             const char* name,

             const char* label,

             MetricUnit::Type unit,

             const char* description,

             MetricLevel level,

             OptionalArgs optional_args = OptionalArgs())

      : entity_type_(entity_type),

        name_(name),

        label_(label),

        unit_(unit),

        description_(description),

        level_(level),

        flags_(optional_args.flags_),

        aggregation_function_(optional_args.aggregation_function_) {

    }

    const char* const entity_type_;

    const char* const name_;

    const char* const label_;

    const MetricUnit::Type unit_;

    const char* const description_;

    const MetricLevel level_;

    const uint32_t flags_;

    const AggregationFunction aggregation_function_;

  };

  const char* entity_type() const { return args_.entity_type_; }

  const char* name() const { return args_.name_; }

  const char* label() const { return args_.label_; }

  MetricUnit::Type unit() const { return args_.unit_; }

  const char* description() const { return args_.description_; }

  MetricLevel level() const { return args_.level_; }

  AggregationFunction aggregation_function() const { return args_.aggregation_function_; }

  virtual MetricType::Type type() const = 0;

  // Writes the fields of this prototype to the given JSON writer.

  void WriteFields(JsonWriter* writer,

                   const MetricJsonOptions& opts) const;

  virtual ~MetricPrototype() {}

 protected:

  explicit MetricPrototype(CtorArgs args);

  const CtorArgs args_;

 private:

  DISALLOW_COPY_AND_ASSIGN(MetricPrototype);

};

// A description of a Gauge.

template<typename T>

class GaugePrototype : public MetricPrototype {

 public:

  explicit GaugePrototype(const MetricPrototype::CtorArgs& args)

    : MetricPrototype(args) {

  }

yb::GaugePrototype<unsigned long long>::GaugePrototype(yb::MetricPrototype::CtorArgs const&)

Line

Count

Source

644

4.26M

    : MetricPrototype(args) {

645

4.26M

  }

yb::GaugePrototype<long long>::GaugePrototype(yb::MetricPrototype::CtorArgs const&)

Line

Count

Source

644

2.97M

    : MetricPrototype(args) {

645

2.97M

  }

yb::GaugePrototype<unsigned int>::GaugePrototype(yb::MetricPrototype::CtorArgs const&)

Line

Count

Source

644

152k

    : MetricPrototype(args) {

645

152k

  }

  // Instantiate a "manual" gauge.

  scoped_refptr<AtomicGauge<T> > Instantiate(

      const scoped_refptr<MetricEntity>& entity,

      const T& initial_value) const {

    return entity->FindOrCreateGauge(this, initial_value);

  }

yb::GaugePrototype<unsigned long long>::Instantiate(scoped_refptr<yb::MetricEntity> const&, unsigned long long const&) const

Line

Count

Source

650

15.0M

      const T& initial_value) const {

651

15.0M

    return entity->FindOrCreateGauge(this, initial_value);

652

15.0M

  }

yb::GaugePrototype<unsigned int>::Instantiate(scoped_refptr<yb::MetricEntity> const&, unsigned int const&) const

Line

Count

Source

650

170k

      const T& initial_value) const {

651

170k

    return entity->FindOrCreateGauge(this, initial_value);

652

170k

  }

yb::GaugePrototype<long long>::Instantiate(scoped_refptr<yb::MetricEntity> const&, long long const&) const

Line

Count

Source

650

998k

      const T& initial_value) const {

651

998k

    return entity->FindOrCreateGauge(this, initial_value);

652

998k

  }

  // Instantiate a gauge that is backed by the given callback.

  scoped_refptr<FunctionGauge<T> > InstantiateFunctionGauge(

      const scoped_refptr<MetricEntity>& entity,

      const Callback<T()>& function) const {

    return entity->FindOrCreateFunctionGauge(this, function);

  }

yb::GaugePrototype<unsigned long long>::InstantiateFunctionGauge(scoped_refptr<yb::MetricEntity> const&, yb::Callback<unsigned long long ()> const&) const

Line

Count

Source

657

394k

      const Callback<T()>& function) const {

658

394k

    return entity->FindOrCreateFunctionGauge(this, function);

659

394k

  }

yb::GaugePrototype<long long>::InstantiateFunctionGauge(scoped_refptr<yb::MetricEntity> const&, yb::Callback<long long ()> const&) const

Line

Count

Source

657

25.7k

      const Callback<T()>& function) const {

658

25.7k

    return entity->FindOrCreateFunctionGauge(this, function);

659

25.7k

  }

  virtual MetricType::Type type() const override {

    if (args_.flags_ & EXPOSE_AS_COUNTER) {

      return MetricType::kCounter;

    } else {

      return MetricType::kGauge;

    }

  }

yb::GaugePrototype<unsigned long long>::type() const

Line

Count

Source

661

22

  virtual MetricType::Type type() const override {

662

22

    if (args_.flags_ & EXPOSE_AS_COUNTER) {

663

8

      return MetricType::kCounter;

664

14

    } else {

665

14

      return MetricType::kGauge;

666

14

    }

667

22

  }

yb::GaugePrototype<long long>::type() const

Line

Count

Source

661

1

  virtual MetricType::Type type() const override {

662

1

    if (args_.flags_ & EXPOSE_AS_COUNTER) {

663

0

      return MetricType::kCounter;

664

1

    } else {

665

1

      return MetricType::kGauge;

666

1

    }

667

1

  }

Unexecuted instantiation: yb::GaugePrototype<unsigned int>::type() const

 private:

  DISALLOW_COPY_AND_ASSIGN(GaugePrototype);

};

// Abstract base class to provide point-in-time metric values.

class Gauge : public Metric {

 public:

  explicit Gauge(const MetricPrototype* prototype)

      : Metric(prototype) {

  }

  explicit Gauge(std::unique_ptr<MetricPrototype> prototype)

      : Metric(std::move(prototype)) {

  }

  virtual ~Gauge() {}

  virtual CHECKED_STATUS WriteAsJson(JsonWriter* w,

                             const MetricJsonOptions& opts) const override;

 protected:

  virtual void WriteValue(JsonWriter* writer) const = 0;

 private:

  DISALLOW_COPY_AND_ASSIGN(Gauge);

};

// Gauge implementation for string that uses locks to ensure thread safety.

class StringGauge : public Gauge {

 public:

  StringGauge(const GaugePrototype<std::string>* proto,

              std::string initial_value);

  std::string value() const;

  void set_value(const std::string& value);

  CHECKED_STATUS WriteForPrometheus(

      PrometheusWriter* writer, const MetricEntity::AttributeMap& attr,

      const MetricPrometheusOptions& opts) const override;

 protected:

  virtual void WriteValue(JsonWriter* writer) const override;

 private:

  std::string value_;

  mutable simple_spinlock lock_;  // Guards value_

  DISALLOW_COPY_AND_ASSIGN(StringGauge);

};

// Lock-free implementation for types that are convertible to/from int64_t.

template <typename T>

class AtomicGauge : public Gauge {

 public:

  AtomicGauge(const GaugePrototype<T>* proto, T initial_value)

      : Gauge(proto), value_(initial_value) {

  }

yb::AtomicGauge<unsigned long long>::AtomicGauge(yb::GaugePrototype<unsigned long long> const*, unsigned long long)

Line

Count

Source

717

15.0M

      : Gauge(proto), value_(initial_value) {

718

15.0M

  }

yb::AtomicGauge<unsigned int>::AtomicGauge(yb::GaugePrototype<unsigned int> const*, unsigned int)

Line

Count

Source

717

49.5k

      : Gauge(proto), value_(initial_value) {

718

49.5k

  }

yb::AtomicGauge<long long>::AtomicGauge(yb::GaugePrototype<long long> const*, long long)

Line

Count

Source

717

1.29M

      : Gauge(proto), value_(initial_value) {

718

1.29M

  }

  AtomicGauge(std::unique_ptr<GaugePrototype<T>> proto, T initial_value)

      : Gauge(std::move(proto)), value_(initial_value) {}

yb::AtomicGauge<long long>::AtomicGauge(std::__1::unique_ptr<yb::GaugePrototype<long long>, std::__1::default_delete<yb::GaugePrototype<long long> > >, long long)

Line

Count

Source

721

2.61M

      : Gauge(std::move(proto)), value_(initial_value) {}

yb::AtomicGauge<unsigned long long>::AtomicGauge(std::__1::unique_ptr<yb::GaugePrototype<unsigned long long>, std::__1::default_delete<yb::GaugePrototype<unsigned long long> > >, unsigned long long)

Line

Count

Source

721

545k

      : Gauge(std::move(proto)), value_(initial_value) {}

  T value() const {

    return static_cast<T>(value_.Load(kMemOrderRelease));

  }

yb::AtomicGauge<unsigned long long>::value() const

Line

Count

Source

723

113M

  T value() const {

724

113M

    return static_cast<T>(value_.Load(kMemOrderRelease));

725

113M

  }

yb::AtomicGauge<unsigned int>::value() const

Line

Count

Source

723

140k

  T value() const {

724

140k

    return static_cast<T>(value_.Load(kMemOrderRelease));

725

140k

  }

yb::AtomicGauge<long long>::value() const

Line

Count

Source

723

8.09M

  T value() const {

724

8.09M

    return static_cast<T>(value_.Load(kMemOrderRelease));

725

8.09M

  }

  virtual void set_value(const T& value) {

    value_.Store(static_cast<int64_t>(value), kMemOrderNoBarrier);

  }

yb::AtomicGauge<unsigned long long>::set_value(unsigned long long const&)

Line

Count

Source

726

13.7M

  virtual void set_value(const T& value) {

727

13.7M

    value_.Store(static_cast<int64_t>(value), kMemOrderNoBarrier);

728

13.7M

  }

yb::AtomicGauge<unsigned int>::set_value(unsigned int const&)

Line

Count

Source

726

5.12M

  virtual void set_value(const T& value) {

727

5.12M

    value_.Store(static_cast<int64_t>(value), kMemOrderNoBarrier);

728

5.12M

  }

yb::AtomicGauge<long long>::set_value(long long const&)

Line

Count

Source

726

126M

  virtual void set_value(const T& value) {

727

126M

    value_.Store(static_cast<int64_t>(value), kMemOrderNoBarrier);

728

126M

  }

  void Increment() {

    value_.IncrementBy(1, kMemOrderNoBarrier);

  }

yb::AtomicGauge<unsigned long long>::Increment()

Line

Count

Source

729

66.5M

  void Increment() {

730

66.5M

    value_.IncrementBy(1, kMemOrderNoBarrier);

731

66.5M

  }

yb::AtomicGauge<unsigned int>::Increment()

Line

Count

Source

729

810k

  void Increment() {

730

810k

    value_.IncrementBy(1, kMemOrderNoBarrier);

731

810k

  }

yb::AtomicGauge<long long>::Increment()

Line

Count

Source

729

282M

  void Increment() {

730

282M

    value_.IncrementBy(1, kMemOrderNoBarrier);

731

282M

  }

  virtual void IncrementBy(int64_t amount) {

    value_.IncrementBy(amount, kMemOrderNoBarrier);

  }

yb::AtomicGauge<unsigned long long>::IncrementBy(long long)

Line

Count

Source

732

3.04G

  virtual void IncrementBy(int64_t amount) {

733

3.04G

    value_.IncrementBy(amount, kMemOrderNoBarrier);

734

3.04G

  }

yb::AtomicGauge<unsigned int>::IncrementBy(long long)

Line

Count

Source

732

806k

  virtual void IncrementBy(int64_t amount) {

733

806k

    value_.IncrementBy(amount, kMemOrderNoBarrier);

734

806k

  }

yb::AtomicGauge<long long>::IncrementBy(long long)

Line

Count

Source

732

3.03G

  virtual void IncrementBy(int64_t amount) {

733

3.03G

    value_.IncrementBy(amount, kMemOrderNoBarrier);

734

3.03G

  }

  void Decrement() {

    IncrementBy(-1);

  }

yb::AtomicGauge<unsigned long long>::Decrement()

Line

Count

Source

735

63.7M

  void Decrement() {

736

63.7M

    IncrementBy(-1);

737

63.7M

  }

yb::AtomicGauge<unsigned int>::Decrement()

Line

Count

Source

735

806k

  void Decrement() {

736

806k

    IncrementBy(-1);

737

806k

  }

yb::AtomicGauge<long long>::Decrement()

Line

Count

Source

735

290M

  void Decrement() {

736

290M

    IncrementBy(-1);

737

290M

  }

  void DecrementBy(int64_t amount) {

    IncrementBy(-amount);

  }

yb::AtomicGauge<unsigned long long>::DecrementBy(long long)

Line

Count

Source

738

357k

  void DecrementBy(int64_t amount) {

739

357k

    IncrementBy(-amount);

740

357k

  }

yb::AtomicGauge<long long>::DecrementBy(long long)

Line

Count

Source

738

25.2M

  void DecrementBy(int64_t amount) {

739

25.2M

    IncrementBy(-amount);

740

25.2M

  }

  CHECKED_STATUS WriteForPrometheus(

      PrometheusWriter* writer, const MetricEntity::AttributeMap& attr,

      const MetricPrometheusOptions& opts) const override {

    if (prototype_->level() < opts.level) {

      return Status::OK();

    }

    return writer->WriteSingleEntry(attr, prototype_->name(), value(),

                                    prototype()->aggregation_function());

  }

yb::AtomicGauge<unsigned long long>::WriteForPrometheus(yb::PrometheusWriter*, std::__1::unordered_map<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::hash<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::equal_to<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::allocator<std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > > const&, yb::MetricPrometheusOptions const&) const

Line

Count

Source

744

19.4k

      const MetricPrometheusOptions& opts) const override {

745

19.4k

    if (prototype_->level() < opts.level) {

746

0

      return Status::OK();

747

0

    }

748

749

19.4k

    return writer->WriteSingleEntry(attr, prototype_->name(), value(),

750

19.4k

                                    prototype()->aggregation_function());

751

19.4k

  }

yb::AtomicGauge<unsigned int>::WriteForPrometheus(yb::PrometheusWriter*, std::__1::unordered_map<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::hash<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::equal_to<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::allocator<std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > > const&, yb::MetricPrometheusOptions const&) const

Line

Count

Source

744

91

      const MetricPrometheusOptions& opts) const override {

745

91

    if (prototype_->level() < opts.level) {

746

0

      return Status::OK();

747

0

    }

748

749

91

    return writer->WriteSingleEntry(attr, prototype_->name(), value(),

750

91

                                    prototype()->aggregation_function());

751

91

  }

yb::AtomicGauge<long long>::WriteForPrometheus(yb::PrometheusWriter*, std::__1::unordered_map<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::hash<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::equal_to<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::allocator<std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > > const&, yb::MetricPrometheusOptions const&) const

Line

Count

Source

744

3.40k

      const MetricPrometheusOptions& opts) const override {

745

3.40k

    if (prototype_->level() < opts.level) {

746

0

      return Status::OK();

747

0

    }

748

749

3.40k

    return writer->WriteSingleEntry(attr, prototype_->name(), value(),

750

3.40k

                                    prototype()->aggregation_function());

751

3.40k

  }

 protected:

  virtual void WriteValue(JsonWriter* writer) const override {

    writer->Value(value());

  }

yb::AtomicGauge<unsigned long long>::WriteValue(yb::JsonWriter*) const

Line

Count

Source

754

50.4M

  virtual void WriteValue(JsonWriter* writer) const override {

755

50.4M

    writer->Value(value());

756

50.4M

  }

yb::AtomicGauge<unsigned int>::WriteValue(yb::JsonWriter*) const

Line

Count

Source

754

140k

  virtual void WriteValue(JsonWriter* writer) const override {

755

140k

    writer->Value(value());

756

140k

  }

yb::AtomicGauge<long long>::WriteValue(yb::JsonWriter*) const

Line

Count

Source

754

8.09M

  virtual void WriteValue(JsonWriter* writer) const override {

755

8.09M

    writer->Value(value());

756

8.09M

  }

  AtomicInt<int64_t> value_;

 private:

  DISALLOW_COPY_AND_ASSIGN(AtomicGauge);

};

template <class T>

void IncrementGauge(const scoped_refptr<AtomicGauge<T>>& gauge) {

  if (gauge) {

    gauge->Increment();

  }

}

void yb::IncrementGauge<long long>(scoped_refptr<yb::AtomicGauge<long long> > const&)

Line

Count

Source

763

180M

void IncrementGauge(const scoped_refptr<AtomicGauge<T>>& gauge) {

764

180M

  if (gauge) {

765

179M

    gauge->Increment();

766

179M

  }

767

180M

}

void yb::IncrementGauge<unsigned int>(scoped_refptr<yb::AtomicGauge<unsigned int> > const&)

Line

Count

Source

763

810k

void IncrementGauge(const scoped_refptr<AtomicGauge<T>>& gauge) {

764

810k

  if (gauge) {

765

810k

    gauge->Increment();

766

810k

  }

767

810k

}

template <class T>

void DecrementGauge(const scoped_refptr<AtomicGauge<T>>& gauge) {

  if (gauge) {

    gauge->Decrement();

  }

}

void yb::DecrementGauge<long long>(scoped_refptr<yb::AtomicGauge<long long> > const&)

Line

Count

Source

770

180M

void DecrementGauge(const scoped_refptr<AtomicGauge<T>>& gauge) {

771

180M

  if (gauge) {

772

178M

    gauge->Decrement();

773

178M

  }

774

180M

}

void yb::DecrementGauge<unsigned int>(scoped_refptr<yb::AtomicGauge<unsigned int> > const&)

Line

Count

Source

770

806k

void DecrementGauge(const scoped_refptr<AtomicGauge<T>>& gauge) {

771

806k

  if (
gauge806k
) {

772

806k

    gauge->Decrement();

773

806k

  }

774

806k

}

// A Gauge that calls back to a function to get its value.

//

// This metric type should be used in cases where it is difficult to keep a running

// measure of a metric, but instead would like to compute the metric value whenever it is

// requested by a user.

//

// The lifecycle should be carefully considered when using a FunctionGauge. In particular,

// the bound function needs to always be safe to run -- so if it references a particular

// non-singleton class instance, the instance must out-live the function. Typically,

// the easiest way to ensure this is to use a FunctionGaugeDetacher (see above).

template <typename T>

class FunctionGauge : public Gauge {

 public:

  T value() const {

    std::lock_guard<simple_spinlock> l(lock_);

    return function_.Run();

  }

yb::FunctionGauge<unsigned long long>::value() const

Line

Count

Source

789

230k

  T value() const {

790

230k

    std::lock_guard<simple_spinlock> l(lock_);

791

230k

    return function_.Run();

792

230k

  }

yb::FunctionGauge<long long>::value() const

Line

Count

Source

789

15.5k

  T value() const {

790

15.5k

    std::lock_guard<simple_spinlock> l(lock_);

791

15.5k

    return function_.Run();

792

15.5k

  }

  virtual void WriteValue(JsonWriter* writer) const override {

    writer->Value(value());

  }

yb::FunctionGauge<unsigned long long>::WriteValue(yb::JsonWriter*) const

Line

Count

Source

794

229k

  virtual void WriteValue(JsonWriter* writer) const override {

795

229k

    writer->Value(value());

796

229k

  }

yb::FunctionGauge<long long>::WriteValue(yb::JsonWriter*) const

Line

Count

Source

794

15.3k

  virtual void WriteValue(JsonWriter* writer) const override {

795

15.3k

    writer->Value(value());

796

15.3k

  }

  // Reset this FunctionGauge to return a specific value.

  // This should be used during destruction. If you want a settable

  // Gauge, use a normal Gauge instead of a FunctionGauge.

  void DetachToConstant(T v) {

    std::lock_guard<simple_spinlock> l(lock_);

    function_ = Bind(&FunctionGauge::Return, v);

  }

yb::FunctionGauge<unsigned long long>::DetachToConstant(unsigned long long)

Line

Count

Source

801

331

  void DetachToConstant(T v) {

802

331

    std::lock_guard<simple_spinlock> l(lock_);

803

331

    function_ = Bind(&FunctionGauge::Return, v);

804

331

  }

yb::FunctionGauge<long long>::DetachToConstant(long long)

Line

Count

Source

801

164

  void DetachToConstant(T v) {

802

164

    std::lock_guard<simple_spinlock> l(lock_);

803

164

    function_ = Bind(&FunctionGauge::Return, v);

804

164

  }

  // Get the current value of the gauge, and detach so that it continues to return this

  // value in perpetuity.

  void DetachToCurrentValue() {

    T last_value = value();

    DetachToConstant(last_value);

  }

yb::FunctionGauge<unsigned long long>::DetachToCurrentValue()

Line

Count

Source

808

331

  void DetachToCurrentValue() {

809

331

    T last_value = value();

810

331

    DetachToConstant(last_value);

811

331

  }

yb::FunctionGauge<long long>::DetachToCurrentValue()

Line

Count

Source

808

162

  void DetachToCurrentValue() {

809

162

    T last_value = value();

810

162

    DetachToConstant(last_value);

811

162

  }

  // Automatically detach this gauge when the given 'detacher' destructs.

  // After detaching, the metric will return 'value' in perpetuity.

  void AutoDetach(std::shared_ptr<void>* detacher, T value = T()) {

    auto old_value = *detacher;

    *detacher = std::shared_ptr<void>(nullptr,

        [self = make_scoped_refptr(this), value, old_value](auto) {

      self->DetachToConstant(value);

    });

  }

  // Automatically detach this gauge when the given 'detacher' destructs.

  // After detaching, the metric will return whatever its value was at the

  // time of detaching.

  //

  // Note that, when using this method, you should be sure that the FunctionGaugeDetacher

  // is destructed before any objects which are required by the gauge implementation.