aboutsummaryrefslogtreecommitdiffstats
path: root/searchcore/src/vespa/searchcore/proton/metrics/trans_log_server_metrics.cpp
blob: a1a683bb8b20e8278411e7087b5f4901ffb72f72 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.

#include "trans_log_server_metrics.h"

using search::transactionlog::DomainInfo;
using search::transactionlog::DomainStats;

namespace proton {

TransLogServerMetrics::DomainMetrics::DomainMetrics(metrics::MetricSet *parent,
                                                    const vespalib::string &documentType)
    : metrics::MetricSet("transactionlog", {{"documenttype", documentType}},
            "Transaction log metrics for a document type", parent),
      entries("entries", {}, "The current number of entries in the transaction log", this),
      diskUsage("disk_usage", {}, "The disk usage (in bytes) of the transaction log", this),
      replayTime("replay_time", {}, "The replay time (in seconds) of the transaction log during start-up", this)
{
}

TransLogServerMetrics::DomainMetrics::~DomainMetrics() = default;

void
TransLogServerMetrics::DomainMetrics::update(const DomainInfo &stats)
{
    entries.set(stats.numEntries);
    diskUsage.set(stats.byteSize);
    replayTime.set(stats.maxSessionRunTime.count());
}

void
TransLogServerMetrics::considerAddDomains(const DomainStats &stats)
{
    for (const auto &elem : stats) {
        const vespalib::string &documentType = elem.first;
        if (_domainMetrics.find(documentType) == _domainMetrics.end()) {
            _domainMetrics[documentType] = std::make_unique<DomainMetrics>(_parent, documentType);
        }
    }
}

void
TransLogServerMetrics::considerRemoveDomains(const DomainStats &stats)
{
    for (auto itr = _domainMetrics.begin(); itr != _domainMetrics.end(); ) {
        const vespalib::string &documentType = itr->first;
        if (stats.find(documentType) == stats.end()) {
            _parent->unregisterMetric(*itr->second);
            itr = _domainMetrics.erase(itr);
        } else {
            ++itr;
        }
    }
}

void
TransLogServerMetrics::updateDomainMetrics(const DomainStats &stats)
{
    for (const auto &elem : stats) {
        const vespalib::string &documentType = elem.first;
        _domainMetrics.find(documentType)->second->update(elem.second);
    }
}

TransLogServerMetrics::TransLogServerMetrics(metrics::MetricSet *parent)
    : _parent(parent)
{
}

TransLogServerMetrics::~TransLogServerMetrics() = default;

void
TransLogServerMetrics::update(const DomainStats &stats)
{
    considerAddDomains(stats);
    considerRemoveDomains(stats);
    updateDomainMetrics(stats);
}

} // namespace proton