ceph/src/include/cephfs/metrics/Types.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #ifndef CEPH_INCLUDE_CEPHFS_METRICS_TYPES_H
   5 #define CEPH_INCLUDE_CEPHFS_METRICS_TYPES_H
   6
   7 #include <string>
   8 #include <boost/variant.hpp>
   9
  10 #include "common/Formatter.h"
  11 #include "include/buffer_fwd.h"
  12 #include "include/encoding.h"
  13 #include "include/int_types.h"
  14 #include "include/stringify.h"
  15 #include "include/utime.h"
  16
  17 namespace ceph { class Formatter; }
  18
  19 enum ClientMetricType {
  20   CLIENT_METRIC_TYPE_CAP_INFO,
  21   CLIENT_METRIC_TYPE_READ_LATENCY,
  22   CLIENT_METRIC_TYPE_WRITE_LATENCY,
  23   CLIENT_METRIC_TYPE_METADATA_LATENCY,
  24   CLIENT_METRIC_TYPE_DENTRY_LEASE,
  25   CLIENT_METRIC_TYPE_OPENED_FILES,
  26   CLIENT_METRIC_TYPE_PINNED_ICAPS,
  27   CLIENT_METRIC_TYPE_OPENED_INODES,
  28 };
  29 inline std::ostream &operator<<(std::ostream &os, const ClientMetricType &type) {
  30   switch(type) {
  31   case ClientMetricType::CLIENT_METRIC_TYPE_CAP_INFO:
  32     os << "CAP_INFO";
  33     break;
  34   case ClientMetricType::CLIENT_METRIC_TYPE_READ_LATENCY:
  35     os << "READ_LATENCY";
  36     break;
  37   case ClientMetricType::CLIENT_METRIC_TYPE_WRITE_LATENCY:
  38     os << "WRITE_LATENCY";
  39     break;
  40   case ClientMetricType::CLIENT_METRIC_TYPE_METADATA_LATENCY:
  41     os << "METADATA_LATENCY";
  42     break;
  43   case ClientMetricType::CLIENT_METRIC_TYPE_DENTRY_LEASE:
  44     os << "DENTRY_LEASE";
  45     break;
  46   case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_FILES:
  47     os << "OPENED_FILES";
  48     break;
  49   case ClientMetricType::CLIENT_METRIC_TYPE_PINNED_ICAPS:
  50     os << "PINNED_ICAPS";
  51     break;
  52   case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_INODES:
  53     os << "OPENED_INODES";
  54     break;
  55   default:
  56     ceph_abort();
  57   }
  58
  59   return os;
  60 }
  61
  62 struct CapInfoPayload {
  63   static const ClientMetricType METRIC_TYPE = ClientMetricType::CLIENT_METRIC_TYPE_CAP_INFO;
  64
  65   uint64_t cap_hits = 0;
  66   uint64_t cap_misses = 0;
  67   uint64_t nr_caps = 0;
  68
  69   CapInfoPayload() { }
  70   CapInfoPayload(uint64_t cap_hits, uint64_t cap_misses, uint64_t nr_caps)
  71     : cap_hits(cap_hits), cap_misses(cap_misses), nr_caps(nr_caps) {
  72   }
  73
  74   void encode(bufferlist &bl) const {
  75     using ceph::encode;
  76     ENCODE_START(1, 1, bl);
  77     encode(cap_hits, bl);
  78     encode(cap_misses, bl);
  79     encode(nr_caps, bl);
  80     ENCODE_FINISH(bl);
  81   }
  82
  83   void decode(bufferlist::const_iterator &iter) {
  84     using ceph::decode;
  85     DECODE_START(1, iter);
  86     decode(cap_hits, iter);
  87     decode(cap_misses, iter);
  88     decode(nr_caps, iter);
  89     DECODE_FINISH(iter);
  90   }
  91
  92   void dump(Formatter *f) const {
  93     f->dump_int("cap_hits", cap_hits);
  94     f->dump_int("cap_misses", cap_misses);
  95     f->dump_int("num_caps", nr_caps);
  96   }
  97
  98   void print(ostream *out) const {
  99     *out << "cap_hits: " << cap_hits << " "
 100          << "cap_misses: " << cap_misses << " "
 101          << "num_caps: " << nr_caps;
 102   }
 103 };
 104
 105 struct ReadLatencyPayload {
 106   static const ClientMetricType METRIC_TYPE = ClientMetricType::CLIENT_METRIC_TYPE_READ_LATENCY;
 107
 108   utime_t lat;
 109
 110   ReadLatencyPayload() { }
 111   ReadLatencyPayload(utime_t lat)
 112     : lat(lat) {
 113   }
 114
 115   void encode(bufferlist &bl) const {
 116     using ceph::encode;
 117     ENCODE_START(1, 1, bl);
 118     encode(lat, bl);
 119     ENCODE_FINISH(bl);
 120   }
 121
 122   void decode(bufferlist::const_iterator &iter) {
 123     using ceph::decode;
 124     DECODE_START(1, iter);
 125     decode(lat, iter);
 126     DECODE_FINISH(iter);
 127   }
 128
 129   void dump(Formatter *f) const {
 130     f->dump_int("latency", lat);
 131   }
 132
 133   void print(ostream *out) const {
 134     *out << "latency: " << lat;
 135   }
 136 };
 137
 138 struct WriteLatencyPayload {
 139   static const ClientMetricType METRIC_TYPE = ClientMetricType::CLIENT_METRIC_TYPE_WRITE_LATENCY;
 140
 141   utime_t lat;
 142
 143   WriteLatencyPayload() { }
 144   WriteLatencyPayload(utime_t lat)
 145     : lat(lat) {
 146   }
 147
 148   void encode(bufferlist &bl) const {
 149     using ceph::encode;
 150     ENCODE_START(1, 1, bl);
 151     encode(lat, bl);
 152     ENCODE_FINISH(bl);
 153   }
 154
 155   void decode(bufferlist::const_iterator &iter) {
 156     using ceph::decode;
 157     DECODE_START(1, iter);
 158     decode(lat, iter);
 159     DECODE_FINISH(iter);
 160   }
 161
 162   void dump(Formatter *f) const {
 163     f->dump_int("latency", lat);
 164   }
 165
 166   void print(ostream *out) const {
 167     *out << "latency: " << lat;
 168   }
 169 };
 170
 171 struct MetadataLatencyPayload {
 172   static const ClientMetricType METRIC_TYPE = ClientMetricType::CLIENT_METRIC_TYPE_METADATA_LATENCY;
 173
 174   utime_t lat;
 175
 176   MetadataLatencyPayload() { }
 177   MetadataLatencyPayload(utime_t lat)
 178     : lat(lat) {
 179   }
 180
 181   void encode(bufferlist &bl) const {
 182     using ceph::encode;
 183     ENCODE_START(1, 1, bl);
 184     encode(lat, bl);
 185     ENCODE_FINISH(bl);
 186   }
 187
 188   void decode(bufferlist::const_iterator &iter) {
 189     using ceph::decode;
 190     DECODE_START(1, iter);
 191     decode(lat, iter);
 192     DECODE_FINISH(iter);
 193   }
 194
 195   void dump(Formatter *f) const {
 196     f->dump_int("latency", lat);
 197   }
 198
 199   void print(ostream *out) const {
 200     *out << "latency: " << lat;
 201   }
 202 };
 203
 204 struct DentryLeasePayload {
 205   static const ClientMetricType METRIC_TYPE = ClientMetricType::CLIENT_METRIC_TYPE_DENTRY_LEASE;
 206
 207   uint64_t dlease_hits = 0;
 208   uint64_t dlease_misses = 0;
 209   uint64_t nr_dentries = 0;
 210
 211   DentryLeasePayload() { }
 212   DentryLeasePayload(uint64_t dlease_hits, uint64_t dlease_misses, uint64_t nr_dentries)
 213     : dlease_hits(dlease_hits), dlease_misses(dlease_misses), nr_dentries(nr_dentries) {
 214   }
 215
 216   void encode(bufferlist &bl) const {
 217     using ceph::encode;
 218     ENCODE_START(1, 1, bl);
 219     encode(dlease_hits, bl);
 220     encode(dlease_misses, bl);
 221     encode(nr_dentries, bl);
 222     ENCODE_FINISH(bl);
 223   }
 224
 225   void decode(bufferlist::const_iterator &iter) {
 226     using ceph::decode;
 227     DECODE_START(1, iter);
 228     decode(dlease_hits, iter);
 229     decode(dlease_misses, iter);
 230     decode(nr_dentries, iter);
 231     DECODE_FINISH(iter);
 232   }
 233
 234   void dump(Formatter *f) const {
 235     f->dump_int("dlease_hits", dlease_hits);
 236     f->dump_int("dlease_misses", dlease_misses);
 237     f->dump_int("num_dentries", nr_dentries);
 238   }
 239
 240   void print(ostream *out) const {
 241     *out << "dlease_hits: " << dlease_hits << " "
 242          << "dlease_misses: " << dlease_misses << " "
 243          << "num_dentries: " << nr_dentries;
 244   }
 245 };
 246
 247 struct OpenedFilesPayload {
 248   static const ClientMetricType METRIC_TYPE = ClientMetricType::CLIENT_METRIC_TYPE_OPENED_FILES;
 249
 250   uint64_t opened_files = 0;
 251   uint64_t total_inodes = 0;
 252
 253   OpenedFilesPayload() { }
 254   OpenedFilesPayload(uint64_t opened_files, uint64_t total_inodes)
 255     : opened_files(opened_files), total_inodes(total_inodes) {
 256   }
 257
 258   void encode(bufferlist &bl) const {
 259     using ceph::encode;
 260     ENCODE_START(1, 1, bl);
 261     encode(opened_files, bl);
 262     encode(total_inodes, bl);
 263     ENCODE_FINISH(bl);
 264   }
 265
 266   void decode(bufferlist::const_iterator &iter) {
 267     using ceph::decode;
 268     DECODE_START(1, iter);
 269     decode(opened_files, iter);
 270     decode(total_inodes, iter);
 271     DECODE_FINISH(iter);
 272   }
 273
 274   void dump(Formatter *f) const {
 275     f->dump_int("opened_files", opened_files);
 276     f->dump_int("total_inodes", total_inodes);
 277   }
 278
 279   void print(ostream *out) const {
 280     *out << "opened_files: " << opened_files << " "
 281          << "total_inodes: " << total_inodes;
 282   }
 283 };
 284
 285 struct PinnedIcapsPayload {
 286   static const ClientMetricType METRIC_TYPE = ClientMetricType::CLIENT_METRIC_TYPE_PINNED_ICAPS;
 287
 288   uint64_t pinned_icaps = 0;
 289   uint64_t total_inodes = 0;
 290
 291   PinnedIcapsPayload() { }
 292   PinnedIcapsPayload(uint64_t pinned_icaps, uint64_t total_inodes)
 293     : pinned_icaps(pinned_icaps), total_inodes(total_inodes) {
 294   }
 295
 296   void encode(bufferlist &bl) const {
 297     using ceph::encode;
 298     ENCODE_START(1, 1, bl);
 299     encode(pinned_icaps, bl);
 300     encode(total_inodes, bl);
 301     ENCODE_FINISH(bl);
 302   }
 303
 304   void decode(bufferlist::const_iterator &iter) {
 305     using ceph::decode;
 306     DECODE_START(1, iter);
 307     decode(pinned_icaps, iter);
 308     decode(total_inodes, iter);
 309     DECODE_FINISH(iter);
 310   }
 311
 312   void dump(Formatter *f) const {
 313     f->dump_int("pinned_icaps", pinned_icaps);
 314     f->dump_int("total_inodes", total_inodes);
 315   }
 316
 317   void print(ostream *out) const {
 318     *out << "pinned_icaps: " << pinned_icaps << " "
 319          << "total_inodes: " << total_inodes;
 320   }
 321 };
 322
 323 struct OpenedInodesPayload {
 324   static const ClientMetricType METRIC_TYPE = ClientMetricType::CLIENT_METRIC_TYPE_OPENED_INODES;
 325
 326   uint64_t opened_inodes = 0;
 327   uint64_t total_inodes = 0;
 328
 329   OpenedInodesPayload() { }
 330   OpenedInodesPayload(uint64_t opened_inodes, uint64_t total_inodes)
 331     : opened_inodes(opened_inodes), total_inodes(total_inodes) {
 332   }
 333
 334   void encode(bufferlist &bl) const {
 335     using ceph::encode;
 336     ENCODE_START(1, 1, bl);
 337     encode(opened_inodes, bl);
 338     encode(total_inodes, bl);
 339     ENCODE_FINISH(bl);
 340   }
 341
 342   void decode(bufferlist::const_iterator &iter) {
 343     using ceph::decode;
 344     DECODE_START(1, iter);
 345     decode(opened_inodes, iter);
 346     decode(total_inodes, iter);
 347     DECODE_FINISH(iter);
 348   }
 349
 350   void dump(Formatter *f) const {
 351     f->dump_int("opened_inodes", opened_inodes);
 352     f->dump_int("total_inodes", total_inodes);
 353   }
 354
 355   void print(ostream *out) const {
 356     *out << "opened_inodes: " << opened_inodes << " "
 357          << "total_inodes: " << total_inodes;
 358   }
 359 };
 360
 361 struct UnknownPayload {
 362   static const ClientMetricType METRIC_TYPE = static_cast<ClientMetricType>(-1);
 363
 364   UnknownPayload() { }
 365
 366   void encode(bufferlist &bl) const {
 367   }
 368
 369   void decode(bufferlist::const_iterator &iter) {
 370     using ceph::decode;
 371     DECODE_START(254, iter);
 372     iter.seek(struct_len);
 373     DECODE_FINISH(iter);
 374   }
 375
 376   void dump(Formatter *f) const {
 377   }
 378
 379   void print(ostream *out) const {
 380   }
 381 };
 382
 383 typedef boost::variant<CapInfoPayload,
 384                        ReadLatencyPayload,
 385                        WriteLatencyPayload,
 386                        MetadataLatencyPayload,
 387                        DentryLeasePayload,
 388                        OpenedFilesPayload,
 389                        PinnedIcapsPayload,
 390                        OpenedInodesPayload,
 391                        UnknownPayload> ClientMetricPayload;
 392
 393 // metric update message sent by clients
 394 struct ClientMetricMessage {
 395 public:
 396   ClientMetricMessage(const ClientMetricPayload &payload = UnknownPayload())
 397     : payload(payload) {
 398   }
 399
 400   class EncodePayloadVisitor : public boost::static_visitor<void> {
 401   public:
 402     explicit EncodePayloadVisitor(bufferlist &bl) : m_bl(bl) {
 403     }
 404
 405     template <typename ClientMetricPayload>
 406     inline void operator()(const ClientMetricPayload &payload) const {
 407       using ceph::encode;
 408       encode(static_cast<uint32_t>(ClientMetricPayload::METRIC_TYPE), m_bl);
 409       payload.encode(m_bl);
 410     }
 411
 412   private:
 413     bufferlist &m_bl;
 414   };
 415
 416   class DecodePayloadVisitor : public boost::static_visitor<void> {
 417   public:
 418     DecodePayloadVisitor(bufferlist::const_iterator &iter) : m_iter(iter) {
 419     }
 420
 421     template <typename ClientMetricPayload>
 422     inline void operator()(ClientMetricPayload &payload) const {
 423       using ceph::decode;
 424       payload.decode(m_iter);
 425     }
 426
 427   private:
 428     bufferlist::const_iterator &m_iter;
 429   };
 430
 431   class DumpPayloadVisitor : public boost::static_visitor<void> {
 432   public:
 433     explicit DumpPayloadVisitor(Formatter *formatter) : m_formatter(formatter) {
 434     }
 435
 436     template <typename ClientMetricPayload>
 437     inline void operator()(const ClientMetricPayload &payload) const {
 438       ClientMetricType metric_type = ClientMetricPayload::METRIC_TYPE;
 439       m_formatter->dump_string("client_metric_type", stringify(metric_type));
 440       payload.dump(m_formatter);
 441     }
 442
 443   private:
 444     Formatter *m_formatter;
 445   };
 446
 447   class PrintPayloadVisitor : public boost::static_visitor<void> {
 448   public:
 449     explicit PrintPayloadVisitor(ostream *out) : _out(out) {
 450     }
 451
 452     template <typename ClientMetricPayload>
 453     inline void operator()(const ClientMetricPayload &payload) const {
 454       ClientMetricType metric_type = ClientMetricPayload::METRIC_TYPE;
 455       *_out << "[client_metric_type: " << metric_type;
 456       payload.print(_out);
 457       *_out << "]";
 458     }
 459
 460   private:
 461     ostream *_out;
 462   };
 463
 464   void encode(bufferlist &bl) const {
 465     boost::apply_visitor(EncodePayloadVisitor(bl), payload);
 466   }
 467
 468   void decode(bufferlist::const_iterator &iter) {
 469     using ceph::decode;
 470
 471     uint32_t metric_type;
 472     decode(metric_type, iter);
 473
 474     switch (metric_type) {
 475     case ClientMetricType::CLIENT_METRIC_TYPE_CAP_INFO:
 476       payload = CapInfoPayload();
 477       break;
 478     case ClientMetricType::CLIENT_METRIC_TYPE_READ_LATENCY:
 479       payload = ReadLatencyPayload();
 480       break;
 481     case ClientMetricType::CLIENT_METRIC_TYPE_WRITE_LATENCY:
 482       payload = WriteLatencyPayload();
 483       break;
 484     case ClientMetricType::CLIENT_METRIC_TYPE_METADATA_LATENCY:
 485       payload = MetadataLatencyPayload();
 486       break;
 487     case ClientMetricType::CLIENT_METRIC_TYPE_DENTRY_LEASE:
 488       payload = DentryLeasePayload();
 489       break;
 490     case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_FILES:
 491       payload = OpenedFilesPayload();
 492       break;
 493     case ClientMetricType::CLIENT_METRIC_TYPE_PINNED_ICAPS:
 494       payload = PinnedIcapsPayload();
 495       break;
 496     case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_INODES:
 497       payload = OpenedInodesPayload();
 498       break;
 499     default:
 500       payload = UnknownPayload();
 501       break;
 502     }
 503
 504     boost::apply_visitor(DecodePayloadVisitor(iter), payload);
 505   }
 506
 507   void dump(Formatter *f) const {
 508     apply_visitor(DumpPayloadVisitor(f), payload);
 509   }
 510
 511   void print(ostream *out) const {
 512     apply_visitor(PrintPayloadVisitor(out), payload);
 513   }
 514
 515   ClientMetricPayload payload;
 516 };
 517 WRITE_CLASS_ENCODER(ClientMetricMessage);
 518
 519 #endif // CEPH_INCLUDE_CEPHFS_METRICS_TYPES_H