1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
4 #ifndef CEPH_INCLUDE_CEPHFS_METRICS_TYPES_H
5 #define CEPH_INCLUDE_CEPHFS_METRICS_TYPES_H
8 #include <boost/variant.hpp>
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"
17 namespace ceph
{ class Formatter
; }
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
,
31 inline std::ostream
&operator<<(std::ostream
&os
, const ClientMetricType
&type
) {
33 case ClientMetricType::CLIENT_METRIC_TYPE_CAP_INFO
:
36 case ClientMetricType::CLIENT_METRIC_TYPE_READ_LATENCY
:
39 case ClientMetricType::CLIENT_METRIC_TYPE_WRITE_LATENCY
:
40 os
<< "WRITE_LATENCY";
42 case ClientMetricType::CLIENT_METRIC_TYPE_METADATA_LATENCY
:
43 os
<< "METADATA_LATENCY";
45 case ClientMetricType::CLIENT_METRIC_TYPE_DENTRY_LEASE
:
48 case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_FILES
:
51 case ClientMetricType::CLIENT_METRIC_TYPE_PINNED_ICAPS
:
54 case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_INODES
:
55 os
<< "OPENED_INODES";
57 case ClientMetricType::CLIENT_METRIC_TYPE_READ_IO_SIZES
:
58 os
<< "READ_IO_SIZES";
60 case ClientMetricType::CLIENT_METRIC_TYPE_WRITE_IO_SIZES
:
61 os
<< "WRITE_IO_SIZES";
64 os
<< "(UNKNOWN:" << static_cast<std::underlying_type
<ClientMetricType
>::type
>(type
) << ")";
71 struct ClientMetricPayloadBase
{
72 ClientMetricPayloadBase(ClientMetricType type
) : metric_type(type
) {}
74 ClientMetricType
get_type() const {
78 void print_type(std::ostream
*out
) const {
83 ClientMetricType metric_type
;
86 struct CapInfoPayload
: public ClientMetricPayloadBase
{
87 uint64_t cap_hits
= 0;
88 uint64_t cap_misses
= 0;
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
) {
98 void encode(bufferlist
&bl
) const {
100 ENCODE_START(1, 1, bl
);
101 encode(cap_hits
, bl
);
102 encode(cap_misses
, bl
);
107 void decode(bufferlist::const_iterator
&iter
) {
109 DECODE_START(1, iter
);
110 decode(cap_hits
, iter
);
111 decode(cap_misses
, iter
);
112 decode(nr_caps
, iter
);
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
);
122 void print(std::ostream
*out
) const {
123 *out
<< "cap_hits: " << cap_hits
<< " "
124 << "cap_misses: " << cap_misses
<< " "
125 << "num_caps: " << nr_caps
;
129 struct ReadLatencyPayload
: public ClientMetricPayloadBase
{
133 : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_READ_LATENCY
) { }
134 ReadLatencyPayload(utime_t lat
)
135 : ClientMetricPayloadBase(ClientMetricType::CLIENT_METRIC_TYPE_READ_LATENCY
), lat(lat
) {
138 void encode(bufferlist
&bl
) const {
140 ENCODE_START(1, 1, bl
);
145 void decode(bufferlist::const_iterator
&iter
) {
147 DECODE_START(1, iter
);
152 void dump(Formatter
*f
) const {
153 f
->dump_int("latency", lat
);
156 void print(std::ostream
*out
) const {
157 *out
<< "latency: " << lat
;
161 struct WriteLatencyPayload
: public ClientMetricPayloadBase
{
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
) {
170 void encode(bufferlist
&bl
) const {
172 ENCODE_START(1, 1, bl
);
177 void decode(bufferlist::const_iterator
&iter
) {
179 DECODE_START(1, iter
);
184 void dump(Formatter
*f
) const {
185 f
->dump_int("latency", lat
);
188 void print(std::ostream
*out
) const {
189 *out
<< "latency: " << lat
;
193 struct MetadataLatencyPayload
: public ClientMetricPayloadBase
{
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
) {
202 void encode(bufferlist
&bl
) const {
204 ENCODE_START(1, 1, bl
);
209 void decode(bufferlist::const_iterator
&iter
) {
211 DECODE_START(1, iter
);
216 void dump(Formatter
*f
) const {
217 f
->dump_int("latency", lat
);
220 void print(std::ostream
*out
) const {
221 *out
<< "latency: " << lat
;
225 struct DentryLeasePayload
: public ClientMetricPayloadBase
{
226 uint64_t dlease_hits
= 0;
227 uint64_t dlease_misses
= 0;
228 uint64_t nr_dentries
= 0;
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
) { }
236 void encode(bufferlist
&bl
) const {
238 ENCODE_START(1, 1, bl
);
239 encode(dlease_hits
, bl
);
240 encode(dlease_misses
, bl
);
241 encode(nr_dentries
, bl
);
245 void decode(bufferlist::const_iterator
&iter
) {
247 DECODE_START(1, iter
);
248 decode(dlease_hits
, iter
);
249 decode(dlease_misses
, iter
);
250 decode(nr_dentries
, iter
);
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
);
260 void print(std::ostream
*out
) const {
261 *out
<< "dlease_hits: " << dlease_hits
<< " "
262 << "dlease_misses: " << dlease_misses
<< " "
263 << "num_dentries: " << nr_dentries
;
267 struct OpenedFilesPayload
: public ClientMetricPayloadBase
{
268 uint64_t opened_files
= 0;
269 uint64_t total_inodes
= 0;
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
) { }
277 void encode(bufferlist
&bl
) const {
279 ENCODE_START(1, 1, bl
);
280 encode(opened_files
, bl
);
281 encode(total_inodes
, bl
);
285 void decode(bufferlist::const_iterator
&iter
) {
287 DECODE_START(1, iter
);
288 decode(opened_files
, iter
);
289 decode(total_inodes
, iter
);
293 void dump(Formatter
*f
) const {
294 f
->dump_int("opened_files", opened_files
);
295 f
->dump_int("total_inodes", total_inodes
);
298 void print(std::ostream
*out
) const {
299 *out
<< "opened_files: " << opened_files
<< " "
300 << "total_inodes: " << total_inodes
;
304 struct PinnedIcapsPayload
: public ClientMetricPayloadBase
{
305 uint64_t pinned_icaps
= 0;
306 uint64_t total_inodes
= 0;
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
) { }
314 void encode(bufferlist
&bl
) const {
316 ENCODE_START(1, 1, bl
);
317 encode(pinned_icaps
, bl
);
318 encode(total_inodes
, bl
);
322 void decode(bufferlist::const_iterator
&iter
) {
324 DECODE_START(1, iter
);
325 decode(pinned_icaps
, iter
);
326 decode(total_inodes
, iter
);
330 void dump(Formatter
*f
) const {
331 f
->dump_int("pinned_icaps", pinned_icaps
);
332 f
->dump_int("total_inodes", total_inodes
);
335 void print(std::ostream
*out
) const {
336 *out
<< "pinned_icaps: " << pinned_icaps
<< " "
337 << "total_inodes: " << total_inodes
;
341 struct OpenedInodesPayload
: public ClientMetricPayloadBase
{
342 uint64_t opened_inodes
= 0;
343 uint64_t total_inodes
= 0;
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
) { }
351 void encode(bufferlist
&bl
) const {
353 ENCODE_START(1, 1, bl
);
354 encode(opened_inodes
, bl
);
355 encode(total_inodes
, bl
);
359 void decode(bufferlist::const_iterator
&iter
) {
361 DECODE_START(1, iter
);
362 decode(opened_inodes
, iter
);
363 decode(total_inodes
, iter
);
367 void dump(Formatter
*f
) const {
368 f
->dump_int("opened_inodes", opened_inodes
);
369 f
->dump_int("total_inodes", total_inodes
);
372 void print(std::ostream
*out
) const {
373 *out
<< "opened_inodes: " << opened_inodes
<< " "
374 << "total_inodes: " << total_inodes
;
378 struct ReadIoSizesPayload
: public ClientMetricPayloadBase
{
379 uint64_t total_ops
= 0;
380 uint64_t total_size
= 0;
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
) { }
388 void encode(bufferlist
&bl
) const {
390 ENCODE_START(1, 1, bl
);
391 encode(total_ops
, bl
);
392 encode(total_size
, bl
);
396 void decode(bufferlist::const_iterator
&iter
) {
398 DECODE_START(1, iter
);
399 decode(total_ops
, iter
);
400 decode(total_size
, iter
);
404 void dump(Formatter
*f
) const {
405 f
->dump_int("total_ops", total_ops
);
406 f
->dump_int("total_size", total_size
);
409 void print(std::ostream
*out
) const {
410 *out
<< "total_ops: " << total_ops
<< " total_size: " << total_size
;
414 struct WriteIoSizesPayload
: public ClientMetricPayloadBase
{
415 uint64_t total_ops
= 0;
416 uint64_t total_size
= 0;
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
) {
425 void encode(bufferlist
&bl
) const {
427 ENCODE_START(1, 1, bl
);
428 encode(total_ops
, bl
);
429 encode(total_size
, bl
);
433 void decode(bufferlist::const_iterator
&iter
) {
435 DECODE_START(1, iter
);
436 decode(total_ops
, iter
);
437 decode(total_size
, iter
);
441 void dump(Formatter
*f
) const {
442 f
->dump_int("total_ops", total_ops
);
443 f
->dump_int("total_size", total_size
);
446 void print(std::ostream
*out
) const {
447 *out
<< "total_ops: " << total_ops
<< " total_size: " << total_size
;
451 struct UnknownPayload
: public ClientMetricPayloadBase
{
453 : ClientMetricPayloadBase(static_cast<ClientMetricType
>(-1)) { }
454 UnknownPayload(ClientMetricType metric_type
)
455 : ClientMetricPayloadBase(metric_type
) { }
457 void encode(bufferlist
&bl
) const {
460 void decode(bufferlist::const_iterator
&iter
) {
462 DECODE_START(254, iter
);
463 iter
.seek(struct_len
);
467 void dump(Formatter
*f
) const {
470 void print(std::ostream
*out
) const {
474 typedef boost::variant
<CapInfoPayload
,
477 MetadataLatencyPayload
,
484 UnknownPayload
> ClientMetricPayload
;
486 // metric update message sent by clients
487 struct ClientMetricMessage
{
489 ClientMetricMessage(const ClientMetricPayload
&payload
= UnknownPayload())
493 class EncodePayloadVisitor
: public boost::static_visitor
<void> {
495 explicit EncodePayloadVisitor(bufferlist
&bl
) : m_bl(bl
) {
498 template <typename ClientMetricPayload
>
499 inline void operator()(const ClientMetricPayload
&payload
) const {
501 encode(static_cast<uint32_t>(payload
.get_type()), m_bl
);
502 payload
.encode(m_bl
);
509 class DecodePayloadVisitor
: public boost::static_visitor
<void> {
511 DecodePayloadVisitor(bufferlist::const_iterator
&iter
) : m_iter(iter
) {
514 template <typename ClientMetricPayload
>
515 inline void operator()(ClientMetricPayload
&payload
) const {
517 payload
.decode(m_iter
);
521 bufferlist::const_iterator
&m_iter
;
524 class DumpPayloadVisitor
: public boost::static_visitor
<void> {
526 explicit DumpPayloadVisitor(Formatter
*formatter
) : m_formatter(formatter
) {
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
);
536 Formatter
*m_formatter
;
539 class PrintPayloadVisitor
: public boost::static_visitor
<void> {
541 explicit PrintPayloadVisitor(std::ostream
*out
) : _out(out
) {
544 template <typename ClientMetricPayload
>
545 inline void operator()(const ClientMetricPayload
&payload
) const {
546 *_out
<< "[client_metric_type: ";
547 payload
.print_type(_out
);
557 void encode(bufferlist
&bl
) const {
558 boost::apply_visitor(EncodePayloadVisitor(bl
), payload
);
561 void decode(bufferlist::const_iterator
&iter
) {
564 uint32_t metric_type
;
565 decode(metric_type
, iter
);
567 switch (metric_type
) {
568 case ClientMetricType::CLIENT_METRIC_TYPE_CAP_INFO
:
569 payload
= CapInfoPayload();
571 case ClientMetricType::CLIENT_METRIC_TYPE_READ_LATENCY
:
572 payload
= ReadLatencyPayload();
574 case ClientMetricType::CLIENT_METRIC_TYPE_WRITE_LATENCY
:
575 payload
= WriteLatencyPayload();
577 case ClientMetricType::CLIENT_METRIC_TYPE_METADATA_LATENCY
:
578 payload
= MetadataLatencyPayload();
580 case ClientMetricType::CLIENT_METRIC_TYPE_DENTRY_LEASE
:
581 payload
= DentryLeasePayload();
583 case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_FILES
:
584 payload
= OpenedFilesPayload();
586 case ClientMetricType::CLIENT_METRIC_TYPE_PINNED_ICAPS
:
587 payload
= PinnedIcapsPayload();
589 case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_INODES
:
590 payload
= OpenedInodesPayload();
592 case ClientMetricType::CLIENT_METRIC_TYPE_READ_IO_SIZES
:
593 payload
= ReadIoSizesPayload();
595 case ClientMetricType::CLIENT_METRIC_TYPE_WRITE_IO_SIZES
:
596 payload
= WriteIoSizesPayload();
599 payload
= UnknownPayload(static_cast<ClientMetricType
>(metric_type
));
603 boost::apply_visitor(DecodePayloadVisitor(iter
), payload
);
606 void dump(Formatter
*f
) const {
607 apply_visitor(DumpPayloadVisitor(f
), payload
);
610 void print(std::ostream
*out
) const {
611 apply_visitor(PrintPayloadVisitor(out
), payload
);
614 ClientMetricPayload payload
;
616 WRITE_CLASS_ENCODER(ClientMetricMessage
);
618 #endif // CEPH_INCLUDE_CEPHFS_METRICS_TYPES_H