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   CLIENT_METRIC_TYPE_READ_IO_SIZES,
  29   CLIENT_METRIC_TYPE_WRITE_IO_SIZES,
  30 };
  31 inline std::ostream &operator<<(std::ostream &os, const ClientMetricType &type) {
  32   switch(type) {
  33   case ClientMetricType::CLIENT_METRIC_TYPE_CAP_INFO:
  34     os << "CAP_INFO";
  35     break;
  36   case ClientMetricType::CLIENT_METRIC_TYPE_READ_LATENCY:
  37     os << "READ_LATENCY";
  38     break;
  39   case ClientMetricType::CLIENT_METRIC_TYPE_WRITE_LATENCY:
  40     os << "WRITE_LATENCY";
  41     break;
  42   case ClientMetricType::CLIENT_METRIC_TYPE_METADATA_LATENCY:
  43     os << "METADATA_LATENCY";
  44     break;
  45   case ClientMetricType::CLIENT_METRIC_TYPE_DENTRY_LEASE:
  46     os << "DENTRY_LEASE";
  47     break;
  48   case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_FILES:
  49     os << "OPENED_FILES";
  50     break;
  51   case ClientMetricType::CLIENT_METRIC_TYPE_PINNED_ICAPS:
  52     os << "PINNED_ICAPS";
  53     break;
  54   case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_INODES:
  55     os << "OPENED_INODES";
  56     break;
  57   case ClientMetricType::CLIENT_METRIC_TYPE_READ_IO_SIZES:
  58     os << "READ_IO_SIZES";
  59     break;
  60   case ClientMetricType::CLIENT_METRIC_TYPE_WRITE_IO_SIZES:
  61     os << "WRITE_IO_SIZES";
  62     break;
  63   default:
  64     os << "(UNKNOWN:" << static_cast<std::underlying_type<ClientMetricType>::type>(type) << ")";
  65     break;
  66   }
  67
  68   return os;
  69 }
  70
  71 struct ClientMetricPayloadBase {
  72   ClientMetricPayloadBase(ClientMetricType type) : metric_type(type) {}
  73
  74   ClientMetricType get_type() const {
  75     return metric_type;
  76   }
  77
  78   void print_type(std::ostream *out) const {
  79     *out << metric_type;
  80   }
  81
  82   private:
  83     ClientMetricType metric_type;
  84 };
  85
  86 struct CapInfoPayload : public ClientMetricPayloadBase {
  87   uint64_t cap_hits = 0;
  88   uint64_t cap_misses = 0;
  89   uint64_t nr_caps = 0;
  90
  91   CapInfoPayload()
  92     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_CAP_INFO) { }
  93   CapInfoPayload(uint64_t cap_hits, uint64_t cap_misses, uint64_t nr_caps)
  94     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_CAP_INFO),
  95     cap_hits(cap_hits), cap_misses(cap_misses), nr_caps(nr_caps) {
  96   }
  97
  98   void encode(bufferlist &bl) const {
  99     using ceph::encode;
 100     ENCODE_START(1, 1, bl);
 101     encode(cap_hits, bl);
 102     encode(cap_misses, bl);
 103     encode(nr_caps, bl);
 104     ENCODE_FINISH(bl);
 105   }
 106
 107   void decode(bufferlist::const_iterator &iter) {
 108     using ceph::decode;
 109     DECODE_START(1, iter);
 110     decode(cap_hits, iter);
 111     decode(cap_misses, iter);
 112     decode(nr_caps, iter);
 113     DECODE_FINISH(iter);
 114   }
 115
 116   void dump(Formatter *f) const {
 117     f->dump_int("cap_hits", cap_hits);
 118     f->dump_int("cap_misses", cap_misses);
 119     f->dump_int("num_caps", nr_caps);
 120   }
 121
 122   void print(std::ostream *out) const {
 123     *out << "cap_hits: " << cap_hits << " "
 124          << "cap_misses: " << cap_misses << " "
 125          << "num_caps: " << nr_caps;
 126   }
 127 };
 128
 129 struct ReadLatencyPayload : public ClientMetricPayloadBase {
 130   utime_t lat;
 131
 132   ReadLatencyPayload()
 133     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_READ_LATENCY) { }
 134   ReadLatencyPayload(utime_t lat)
 135     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_READ_LATENCY), lat(lat) {
 136   }
 137
 138   void encode(bufferlist &bl) const {
 139     using ceph::encode;
 140     ENCODE_START(1, 1, bl);
 141     encode(lat, bl);
 142     ENCODE_FINISH(bl);
 143   }
 144
 145   void decode(bufferlist::const_iterator &iter) {
 146     using ceph::decode;
 147     DECODE_START(1, iter);
 148     decode(lat, iter);
 149     DECODE_FINISH(iter);
 150   }
 151
 152   void dump(Formatter *f) const {
 153     f->dump_int("latency", lat);
 154   }
 155
 156   void print(std::ostream *out) const {
 157     *out << "latency: " << lat;
 158   }
 159 };
 160
 161 struct WriteLatencyPayload : public ClientMetricPayloadBase {
 162   utime_t lat;
 163
 164   WriteLatencyPayload()
 165     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_WRITE_LATENCY) { }
 166   WriteLatencyPayload(utime_t lat)
 167     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_WRITE_LATENCY), lat(lat) {
 168   }
 169
 170   void encode(bufferlist &bl) const {
 171     using ceph::encode;
 172     ENCODE_START(1, 1, bl);
 173     encode(lat, bl);
 174     ENCODE_FINISH(bl);
 175   }
 176
 177   void decode(bufferlist::const_iterator &iter) {
 178     using ceph::decode;
 179     DECODE_START(1, iter);
 180     decode(lat, iter);
 181     DECODE_FINISH(iter);
 182   }
 183
 184   void dump(Formatter *f) const {
 185     f->dump_int("latency", lat);
 186   }
 187
 188   void print(std::ostream *out) const {
 189     *out << "latency: " << lat;
 190   }
 191 };
 192
 193 struct MetadataLatencyPayload : public ClientMetricPayloadBase {
 194   utime_t lat;
 195
 196   MetadataLatencyPayload()
 197     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_METADATA_LATENCY) { }
 198   MetadataLatencyPayload(utime_t lat)
 199     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_METADATA_LATENCY), lat(lat) {
 200   }
 201
 202   void encode(bufferlist &bl) const {
 203     using ceph::encode;
 204     ENCODE_START(1, 1, bl);
 205     encode(lat, bl);
 206     ENCODE_FINISH(bl);
 207   }
 208
 209   void decode(bufferlist::const_iterator &iter) {
 210     using ceph::decode;
 211     DECODE_START(1, iter);
 212     decode(lat, iter);
 213     DECODE_FINISH(iter);
 214   }
 215
 216   void dump(Formatter *f) const {
 217     f->dump_int("latency", lat);
 218   }
 219
 220   void print(std::ostream *out) const {
 221     *out << "latency: " << lat;
 222   }
 223 };
 224
 225 struct DentryLeasePayload : public ClientMetricPayloadBase {
 226   uint64_t dlease_hits = 0;
 227   uint64_t dlease_misses = 0;
 228   uint64_t nr_dentries = 0;
 229
 230   DentryLeasePayload()
 231     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_DENTRY_LEASE) { }
 232   DentryLeasePayload(uint64_t dlease_hits, uint64_t dlease_misses, uint64_t nr_dentries)
 233     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_DENTRY_LEASE),
 234     dlease_hits(dlease_hits), dlease_misses(dlease_misses), nr_dentries(nr_dentries) { }
 235
 236   void encode(bufferlist &bl) const {
 237     using ceph::encode;
 238     ENCODE_START(1, 1, bl);
 239     encode(dlease_hits, bl);
 240     encode(dlease_misses, bl);
 241     encode(nr_dentries, bl);
 242     ENCODE_FINISH(bl);
 243   }
 244
 245   void decode(bufferlist::const_iterator &iter) {
 246     using ceph::decode;
 247     DECODE_START(1, iter);
 248     decode(dlease_hits, iter);
 249     decode(dlease_misses, iter);
 250     decode(nr_dentries, iter);
 251     DECODE_FINISH(iter);
 252   }
 253
 254   void dump(Formatter *f) const {
 255     f->dump_int("dlease_hits", dlease_hits);
 256     f->dump_int("dlease_misses", dlease_misses);
 257     f->dump_int("num_dentries", nr_dentries);
 258   }
 259
 260   void print(std::ostream *out) const {
 261     *out << "dlease_hits: " << dlease_hits << " "
 262          << "dlease_misses: " << dlease_misses << " "
 263          << "num_dentries: " << nr_dentries;
 264   }
 265 };
 266
 267 struct OpenedFilesPayload : public ClientMetricPayloadBase {
 268   uint64_t opened_files = 0;
 269   uint64_t total_inodes = 0;
 270
 271   OpenedFilesPayload()
 272     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_OPENED_FILES) { }
 273   OpenedFilesPayload(uint64_t opened_files, uint64_t total_inodes)
 274     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_OPENED_FILES),
 275     opened_files(opened_files), total_inodes(total_inodes) { }
 276
 277   void encode(bufferlist &bl) const {
 278     using ceph::encode;
 279     ENCODE_START(1, 1, bl);
 280     encode(opened_files, bl);
 281     encode(total_inodes, bl);
 282     ENCODE_FINISH(bl);
 283   }
 284
 285   void decode(bufferlist::const_iterator &iter) {
 286     using ceph::decode;
 287     DECODE_START(1, iter);
 288     decode(opened_files, iter);
 289     decode(total_inodes, iter);
 290     DECODE_FINISH(iter);
 291   }
 292
 293   void dump(Formatter *f) const {
 294     f->dump_int("opened_files", opened_files);
 295     f->dump_int("total_inodes", total_inodes);
 296   }
 297
 298   void print(std::ostream *out) const {
 299     *out << "opened_files: " << opened_files << " "
 300          << "total_inodes: " << total_inodes;
 301   }
 302 };
 303
 304 struct PinnedIcapsPayload : public ClientMetricPayloadBase {
 305   uint64_t pinned_icaps = 0;
 306   uint64_t total_inodes = 0;
 307
 308   PinnedIcapsPayload()
 309     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_PINNED_ICAPS) { }
 310   PinnedIcapsPayload(uint64_t pinned_icaps, uint64_t total_inodes)
 311     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_PINNED_ICAPS),
 312     pinned_icaps(pinned_icaps), total_inodes(total_inodes) { }
 313
 314   void encode(bufferlist &bl) const {
 315     using ceph::encode;
 316     ENCODE_START(1, 1, bl);
 317     encode(pinned_icaps, bl);
 318     encode(total_inodes, bl);
 319     ENCODE_FINISH(bl);
 320   }
 321
 322   void decode(bufferlist::const_iterator &iter) {
 323     using ceph::decode;
 324     DECODE_START(1, iter);
 325     decode(pinned_icaps, iter);
 326     decode(total_inodes, iter);
 327     DECODE_FINISH(iter);
 328   }
 329
 330   void dump(Formatter *f) const {
 331     f->dump_int("pinned_icaps", pinned_icaps);
 332     f->dump_int("total_inodes", total_inodes);
 333   }
 334
 335   void print(std::ostream *out) const {
 336     *out << "pinned_icaps: " << pinned_icaps << " "
 337          << "total_inodes: " << total_inodes;
 338   }
 339 };
 340
 341 struct OpenedInodesPayload : public ClientMetricPayloadBase {
 342   uint64_t opened_inodes = 0;
 343   uint64_t total_inodes = 0;
 344
 345   OpenedInodesPayload()
 346     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_OPENED_INODES) { }
 347   OpenedInodesPayload(uint64_t opened_inodes, uint64_t total_inodes)
 348     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_OPENED_INODES),
 349     opened_inodes(opened_inodes), total_inodes(total_inodes) { }
 350
 351   void encode(bufferlist &bl) const {
 352     using ceph::encode;
 353     ENCODE_START(1, 1, bl);
 354     encode(opened_inodes, bl);
 355     encode(total_inodes, bl);
 356     ENCODE_FINISH(bl);
 357   }
 358
 359   void decode(bufferlist::const_iterator &iter) {
 360     using ceph::decode;
 361     DECODE_START(1, iter);
 362     decode(opened_inodes, iter);
 363     decode(total_inodes, iter);
 364     DECODE_FINISH(iter);
 365   }
 366
 367   void dump(Formatter *f) const {
 368     f->dump_int("opened_inodes", opened_inodes);
 369     f->dump_int("total_inodes", total_inodes);
 370   }
 371
 372   void print(std::ostream *out) const {
 373     *out << "opened_inodes: " << opened_inodes << " "
 374          << "total_inodes: " << total_inodes;
 375   }
 376 };
 377
 378 struct ReadIoSizesPayload : public ClientMetricPayloadBase {
 379   uint64_t total_ops = 0;
 380   uint64_t total_size = 0;
 381
 382   ReadIoSizesPayload()
 383     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_READ_IO_SIZES) { }
 384   ReadIoSizesPayload(uint64_t total_ops, uint64_t total_size)
 385     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_READ_IO_SIZES),
 386     total_ops(total_ops), total_size(total_size) {  }
 387
 388   void encode(bufferlist &bl) const {
 389     using ceph::encode;
 390     ENCODE_START(1, 1, bl);
 391     encode(total_ops, bl);
 392     encode(total_size, bl);
 393     ENCODE_FINISH(bl);
 394   }
 395
 396   void decode(bufferlist::const_iterator &iter) {
 397     using ceph::decode;
 398     DECODE_START(1, iter);
 399     decode(total_ops, iter);
 400     decode(total_size, iter);
 401     DECODE_FINISH(iter);
 402   }
 403
 404   void dump(Formatter *f) const {
 405     f->dump_int("total_ops", total_ops);
 406     f->dump_int("total_size", total_size);
 407   }
 408
 409   void print(std::ostream *out) const {
 410     *out << "total_ops: " << total_ops << " total_size: " << total_size;
 411   }
 412 };
 413
 414 struct WriteIoSizesPayload : public ClientMetricPayloadBase {
 415   uint64_t total_ops = 0;
 416   uint64_t total_size = 0;
 417
 418   WriteIoSizesPayload()
 419     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_WRITE_IO_SIZES) { }
 420   WriteIoSizesPayload(uint64_t total_ops, uint64_t total_size)
 421     : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_WRITE_IO_SIZES),
 422     total_ops(total_ops), total_size(total_size) {
 423   }
 424
 425   void encode(bufferlist &bl) const {
 426     using ceph::encode;
 427     ENCODE_START(1, 1, bl);
 428     encode(total_ops, bl);
 429     encode(total_size, bl);
 430     ENCODE_FINISH(bl);
 431   }
 432
 433   void decode(bufferlist::const_iterator &iter) {
 434     using ceph::decode;
 435     DECODE_START(1, iter);
 436     decode(total_ops, iter);
 437     decode(total_size, iter);
 438     DECODE_FINISH(iter);
 439   }
 440
 441   void dump(Formatter *f) const {
 442     f->dump_int("total_ops", total_ops);
 443     f->dump_int("total_size", total_size);
 444   }
 445
 446   void print(std::ostream *out) const {
 447     *out << "total_ops: " << total_ops << " total_size: " << total_size;
 448   }
 449 };
 450
 451 struct UnknownPayload : public ClientMetricPayloadBase {
 452   UnknownPayload()
 453     : ClientMetricPayloadBase(static_cast<ClientMetricType>(-1)) { }
 454   UnknownPayload(ClientMetricType metric_type)
 455     : ClientMetricPayloadBase(metric_type) { }
 456
 457   void encode(bufferlist &bl) const {
 458   }
 459
 460   void decode(bufferlist::const_iterator &iter) {
 461     using ceph::decode;
 462     DECODE_START(254, iter);
 463     iter.seek(struct_len);
 464     DECODE_FINISH(iter);
 465   }
 466
 467   void dump(Formatter *f) const {
 468   }
 469
 470   void print(std::ostream *out) const {
 471   }
 472 };
 473
 474 typedef boost::variant<CapInfoPayload,
 475                        ReadLatencyPayload,
 476                        WriteLatencyPayload,
 477                        MetadataLatencyPayload,
 478                        DentryLeasePayload,
 479                        OpenedFilesPayload,
 480                        PinnedIcapsPayload,
 481                        OpenedInodesPayload,
 482                        ReadIoSizesPayload,
 483                        WriteIoSizesPayload,
 484                        UnknownPayload> ClientMetricPayload;
 485
 486 // metric update message sent by clients
 487 struct ClientMetricMessage {
 488 public:
 489   ClientMetricMessage(const ClientMetricPayload &payload = UnknownPayload())
 490     : payload(payload) {
 491   }
 492
 493   class EncodePayloadVisitor : public boost::static_visitor<void> {
 494   public:
 495     explicit EncodePayloadVisitor(bufferlist &bl) : m_bl(bl) {
 496     }
 497
 498     template <typename ClientMetricPayload>
 499     inline void operator()(const ClientMetricPayload &payload) const {
 500       using ceph::encode;
 501       encode(static_cast<uint32_t>(payload.get_type()), m_bl);
 502       payload.encode(m_bl);
 503     }
 504
 505   private:
 506     bufferlist &m_bl;
 507   };
 508
 509   class DecodePayloadVisitor : public boost::static_visitor<void> {
 510   public:
 511     DecodePayloadVisitor(bufferlist::const_iterator &iter) : m_iter(iter) {
 512     }
 513
 514     template <typename ClientMetricPayload>
 515     inline void operator()(ClientMetricPayload &payload) const {
 516       using ceph::decode;
 517       payload.decode(m_iter);
 518     }
 519
 520   private:
 521     bufferlist::const_iterator &m_iter;
 522   };
 523
 524   class DumpPayloadVisitor : public boost::static_visitor<void> {
 525   public:
 526     explicit DumpPayloadVisitor(Formatter *formatter) : m_formatter(formatter) {
 527     }
 528
 529     template <typename ClientMetricPayload>
 530     inline void operator()(const ClientMetricPayload &payload) const {
 531       m_formatter->dump_string("client_metric_type", stringify(payload.get_type()));
 532       payload.dump(m_formatter);
 533     }
 534
 535   private:
 536     Formatter *m_formatter;
 537   };
 538
 539   class PrintPayloadVisitor : public boost::static_visitor<void> {
 540   public:
 541     explicit PrintPayloadVisitor(std::ostream *out) : _out(out) {
 542     }
 543
 544     template <typename ClientMetricPayload>
 545     inline void operator()(const ClientMetricPayload &payload) const {
 546       *_out << "[client_metric_type: ";
 547       payload.print_type(_out);
 548       *_out << " ";
 549       payload.print(_out);
 550       *_out << "]";
 551     }
 552
 553   private:
 554     std::ostream *_out;
 555   };
 556
 557   void encode(bufferlist &bl) const {
 558     boost::apply_visitor(EncodePayloadVisitor(bl), payload);
 559   }
 560
 561   void decode(bufferlist::const_iterator &iter) {
 562     using ceph::decode;
 563
 564     uint32_t metric_type;
 565     decode(metric_type, iter);
 566
 567     switch (metric_type) {
 568     case ClientMetricType::CLIENT_METRIC_TYPE_CAP_INFO:
 569       payload = CapInfoPayload();
 570       break;
 571     case ClientMetricType::CLIENT_METRIC_TYPE_READ_LATENCY:
 572       payload = ReadLatencyPayload();
 573       break;
 574     case ClientMetricType::CLIENT_METRIC_TYPE_WRITE_LATENCY:
 575       payload = WriteLatencyPayload();
 576       break;
 577     case ClientMetricType::CLIENT_METRIC_TYPE_METADATA_LATENCY:
 578       payload = MetadataLatencyPayload();
 579       break;
 580     case ClientMetricType::CLIENT_METRIC_TYPE_DENTRY_LEASE:
 581       payload = DentryLeasePayload();
 582       break;
 583     case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_FILES:
 584       payload = OpenedFilesPayload();
 585       break;
 586     case ClientMetricType::CLIENT_METRIC_TYPE_PINNED_ICAPS:
 587       payload = PinnedIcapsPayload();
 588       break;
 589     case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_INODES:
 590       payload = OpenedInodesPayload();
 591       break;
 592     case ClientMetricType::CLIENT_METRIC_TYPE_READ_IO_SIZES:
 593       payload = ReadIoSizesPayload();
 594       break;
 595     case ClientMetricType::CLIENT_METRIC_TYPE_WRITE_IO_SIZES:
 596       payload = WriteIoSizesPayload();
 597       break;
 598     default:
 599       payload = UnknownPayload(static_cast<ClientMetricType>(metric_type));
 600       break;
 601     }
 602
 603     boost::apply_visitor(DecodePayloadVisitor(iter), payload);
 604   }
 605
 606   void dump(Formatter *f) const {
 607     apply_visitor(DumpPayloadVisitor(f), payload);
 608   }
 609
 610   void print(std::ostream *out) const {
 611     apply_visitor(PrintPayloadVisitor(out), payload);
 612   }
 613
 614   ClientMetricPayload payload;
 615 };
 616 WRITE_CLASS_ENCODER(ClientMetricMessage);
 617
 618 #endif // CEPH_INCLUDE_CEPHFS_METRICS_TYPES_H