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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/enterprise/client_certificates/core/metrics_util.h"
#include "base/metrics/histogram_functions.h"
#include "base/strings/stringprintf.h"
#include "base/time/time.h"
namespace client_certificates {
namespace {
std::string_view ProvisioningScenarioToString(ProvisioningScenario scenario) {
switch (scenario) {
case ProvisioningScenario::kUnknown:
return "Unknown";
case ProvisioningScenario::kCertificateCreation:
return "CertificateCreation";
case ProvisioningScenario::kCertificateRenewal:
return "CertificateRenewal";
case ProvisioningScenario::kExistingIdentity:
return "ExistingIdentity";
}
}
std::string_view SuccessToString(bool success) {
return success ? "Success" : "Failure";
}
std::string_view WithRetryToString(bool with_retry) {
return with_retry ? "WithRetry" : "NoRetry";
}
} // namespace
void LogProvisioningError(const std::string& logging_context,
ProvisioningError provisioning_error,
std::optional<StoreError> store_error) {
static constexpr char kProvisioningErrorHistogram[] =
"Enterprise.ClientCertificate.%s.Provisioning.Error";
base::UmaHistogramEnumeration(
base::StringPrintf(kProvisioningErrorHistogram, logging_context.c_str()),
provisioning_error);
if (store_error.has_value()) {
static constexpr char kProvisioningStoreErrorHistogram[] =
"Enterprise.ClientCertificate.%s.Provisioning.Store.Error";
base::UmaHistogramEnumeration(
base::StringPrintf(kProvisioningStoreErrorHistogram,
logging_context.c_str()),
store_error.value());
}
}
void LogCertificateCreationResponse(const std::string& logging_context,
HttpCodeOrClientError upload_code,
bool has_certificate) {
if (!upload_code.has_value()) {
static constexpr char kCreateCertificateClientErrorHistogram[] =
"Enterprise.ClientCertificate.%s.CreateCertificate.ClientError";
base::UmaHistogramEnumeration(
base::StringPrintf(kCreateCertificateClientErrorHistogram,
logging_context.c_str()),
upload_code.error());
return;
}
static constexpr char kCreateCertificateCodeHistogram[] =
"Enterprise.ClientCertificate.%s.CreateCertificate.UploadCode";
base::UmaHistogramSparse(base::StringPrintf(kCreateCertificateCodeHistogram,
logging_context.c_str()),
upload_code.value());
if (upload_code.value() / 100 == 2) {
static constexpr char kCreateCertificateSuccessHasCertHistogram[] =
"Enterprise.ClientCertificate.%s.CreateCertificate.Success."
"HasCert";
base::UmaHistogramBoolean(
base::StringPrintf(kCreateCertificateSuccessHasCertHistogram,
logging_context.c_str()),
has_certificate);
}
}
void LogProvisioningContext(const std::string& logging_context,
ProvisioningContext context,
bool success) {
static constexpr char kProvisioningOutcomeHistogramFormat[] =
"Enterprise.ClientCertificate.%s.Provisioning.%s.Outcome";
static constexpr char kProvisioningLatencyHistogramFormat[] =
"Enterprise.ClientCertificate.%s.Provisioning.%s.%s.Latency";
auto scenario_string = ProvisioningScenarioToString(context.scenario);
base::UmaHistogramBoolean(
base::StringPrintf(kProvisioningOutcomeHistogramFormat,
logging_context.c_str(), scenario_string.data()),
success);
base::UmaHistogramTimes(
base::StringPrintf(kProvisioningLatencyHistogramFormat,
logging_context.c_str(), scenario_string.data(),
SuccessToString(success).data()),
base::TimeTicks::Now() - context.start_time);
}
void LogPrivateKeyCreationSource(const std::string& logging_context,
PrivateKeySource source) {
static constexpr char kCreatePrivateKeySourceHistogram[] =
"Enterprise.ClientCertificate.%s.CreatePrivateKey.Source";
base::UmaHistogramEnumeration(
base::StringPrintf(kCreatePrivateKeySourceHistogram,
logging_context.c_str()),
source);
}
void LogLevelDBInitStatus(leveldb_proto::Enums::InitStatus status,
bool with_retry) {
static constexpr char kLevelDBInitHistogramFormat[] =
"Enterprise.CertificateStore.LevelDB.InitStatus.%s";
base::UmaHistogramSparse(
base::StringPrintf(kLevelDBInitHistogramFormat,
WithRetryToString(with_retry).data()),
status);
}
} // namespace client_certificates
|
