a7aa1c5013
This reverts commit 5400741601.
Reason for revert: broke hidl build
Change-Id: I3954a1c0d6c0d7a663bd2a1c8c8888cae37cee80
452 lines
20 KiB
C++
452 lines
20 KiB
C++
// Copyright 2021 Google LLC. All Rights Reserved. This file and proprietary
|
|
// source code may only be used and distributed under the Widevine License
|
|
// Agreement.
|
|
//
|
|
// Format widevine protobuf metrics
|
|
|
|
#include "wv_metrics.h"
|
|
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <memory>
|
|
#include <sstream>
|
|
#include <string>
|
|
|
|
#include "OEMCryptoCENC.h"
|
|
#include "wv_cdm_types.h"
|
|
|
|
using namespace drm_metrics;
|
|
using std::string;
|
|
using std::to_string;
|
|
|
|
namespace {
|
|
const string kIndentPerLine = " ";
|
|
|
|
string FormatCdmErrorTranslation(int error_code) {
|
|
std::stringstream os;
|
|
os << static_cast<wvcdm::CdmResponseType>(error_code);
|
|
return " " + os.str();
|
|
}
|
|
|
|
string FormatOEMCryptoResult(int oemcrypto_result) {
|
|
std::stringstream os;
|
|
os << static_cast<OEMCryptoResult>(oemcrypto_result);
|
|
return " " + os.str();
|
|
}
|
|
|
|
string FormatOEMCryptoInitializeMode(const ValueMetric& vm) {
|
|
std::map<int, string> translations = {
|
|
{0, "USING_IN_APP"},
|
|
{1, "FORCING_L3"},
|
|
{2, "USING_L3_NO_L1_LIBRARY_PATH"},
|
|
{3, "USING_L3_L1_OPEN_FAILED"},
|
|
{4, "USING_L3_L1_LOAD_FAILED"},
|
|
{5, "USING_L3_COULD_NOT_INITIALIZE_L1"},
|
|
{6, "USING_L3_WRONG_L1_VERSION"},
|
|
{7, "USING_L1_WITH_KEYBOX"},
|
|
{8, "USING_L1_WITH_CERTIFICATE"},
|
|
{9, "USING_L1_CERTIFICATE_MIX"},
|
|
{10, "USING_L3_BAD_KEYBOX"},
|
|
{11, "USING_L3_COULD_NOT_OPEN_FACTORY_KEYBOX"},
|
|
{12, "USING_L3_COULD_NOT_INSTALL_KEYBOX"},
|
|
{13, "USING_L1_INSTALLED_KEYBOX"},
|
|
{14, "USING_L3_INVALID_L1"},
|
|
{15, "USING_L1_WITH_PROVISIONING_3_0"},
|
|
{16, "L3_INITIALIZATION_GENERAL_FAILED"},
|
|
{17, "L3_INITIALIZATION_RNG_FAILED"},
|
|
{18, "L3_INITIALIZATION_SAVE_DEVICE_KEYS_FAILED"},
|
|
{19, "L3_INITIALIZATION_READ_DEVICE_KEYS_FAILED"},
|
|
{20, "L3_INITIALIZATION_VERIFY_DEVIE_KEYS_FAILED"}};
|
|
return translations[vm.int_value()];
|
|
}
|
|
|
|
string FormatOEMCryptoHdcpCapability(const ValueMetric& vm) {
|
|
std::map<int, string> translations = {
|
|
{0, "HDCP_NONE"}, {1, "HDCP_V1"}, {2, "HDCP_V2"},
|
|
{3, "HDCP_V2_1"}, {4, "HDCP_V2_2"}, {5, "HDCP_V2_3"},
|
|
{0xff, "NO_DIGITAL_OUTPUT"}};
|
|
return translations[vm.int_value()];
|
|
}
|
|
|
|
string FormatOEMCryptoProvisioningMethod(const ValueMetric& vm) {
|
|
std::map<int, string> translations = {{0, "PROVISIONING_ERROR"},
|
|
{1, "DRM_CERTIFICATE"},
|
|
{2, "KEYBOX"},
|
|
{3, "OEM_CERTIFICATE"}};
|
|
return translations[vm.int_value()];
|
|
}
|
|
|
|
string FormatAttributes(const Attributes& attributes) {
|
|
string result;
|
|
if (attributes.has_error_code()) {
|
|
result.append("error_code:");
|
|
result.append(to_string(attributes.error_code()));
|
|
result.append(FormatCdmErrorTranslation(attributes.error_code()));
|
|
}
|
|
if (attributes.has_error_code_bool()) {
|
|
if (result.size()) result.append(",");
|
|
result.append("success:");
|
|
result.append(attributes.error_code_bool() ? "true" : "false");
|
|
}
|
|
if (attributes.has_cdm_security_level()) {
|
|
if (result.size()) result.append(",");
|
|
result.append("cdm_security_level:");
|
|
result.append(to_string(attributes.cdm_security_level()));
|
|
}
|
|
if (attributes.has_security_level()) {
|
|
if (result.size()) result.append(",");
|
|
result.append("security_level:");
|
|
result.append(to_string(attributes.security_level()));
|
|
}
|
|
if (attributes.has_length()) {
|
|
if (result.size()) result.append(",");
|
|
result.append("length:");
|
|
result.append(to_string(attributes.length()));
|
|
}
|
|
if (attributes.has_encryption_algorithm()) {
|
|
if (result.size()) result.append(",");
|
|
result.append("encryption_algorithm:");
|
|
result.append(to_string(attributes.encryption_algorithm()));
|
|
}
|
|
if (attributes.has_signing_algorithm()) {
|
|
if (result.size()) result.append(",");
|
|
result.append("signing_algorithm:");
|
|
result.append(to_string(attributes.signing_algorithm()));
|
|
}
|
|
if (attributes.has_oem_crypto_result()) {
|
|
if (result.size()) result.append(",");
|
|
result.append("oemcrypto_result:");
|
|
result.append(to_string(attributes.oem_crypto_result()));
|
|
result.append(FormatOEMCryptoResult(attributes.oem_crypto_result()));
|
|
}
|
|
if (attributes.has_key_status_type()) {
|
|
if (result.size()) result.append(",");
|
|
result.append("key_status_type:");
|
|
result.append(to_string(attributes.key_status_type()));
|
|
}
|
|
if (attributes.has_event_type()) {
|
|
if (result.size()) result.append(",");
|
|
result.append("event_type:");
|
|
result.append(to_string(attributes.event_type()));
|
|
}
|
|
if (attributes.has_key_request_type()) {
|
|
if (result.size()) result.append(",");
|
|
result.append("key_request_type:");
|
|
result.append(to_string(attributes.key_request_type()));
|
|
}
|
|
if (attributes.has_license_type()) {
|
|
if (result.size()) result.append(",");
|
|
result.append("license_type:");
|
|
result.append(to_string(attributes.license_type()));
|
|
}
|
|
if (result.size()) {
|
|
return string(" {") + result + "}";
|
|
} else {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
string FormatCounterMetric(const CounterMetric& cm) {
|
|
string result;
|
|
if (cm.has_count()) {
|
|
result = string("count=") + to_string(cm.count());
|
|
if (cm.has_attributes()) {
|
|
result.append(FormatAttributes(cm.attributes()));
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
string FormatDistributionMetric(const DistributionMetric& dm) {
|
|
string result;
|
|
if (dm.has_min()) {
|
|
std::ostringstream buffer;
|
|
buffer << dm.min();
|
|
result = string("min=") + buffer.str();
|
|
}
|
|
if (dm.has_max()) {
|
|
std::ostringstream buffer;
|
|
buffer << dm.max();
|
|
if (result.size()) result.append(" ");
|
|
result += string("max=") + buffer.str();
|
|
}
|
|
if (dm.has_mean()) {
|
|
std::ostringstream buffer;
|
|
buffer << dm.mean();
|
|
if (result.size()) result.append(" ");
|
|
result += string("mean=") + buffer.str();
|
|
}
|
|
if (dm.has_variance()) {
|
|
std::ostringstream buffer;
|
|
buffer << dm.variance();
|
|
if (result.size()) result.append(" ");
|
|
result += string("variance=") + buffer.str();
|
|
}
|
|
if (dm.has_operation_count()) {
|
|
if (result.size()) result.append(" ");
|
|
result += string("count=") + to_string(dm.operation_count());
|
|
}
|
|
if (dm.has_attributes()) {
|
|
result.append(FormatAttributes(dm.attributes()));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
string FormatValueMetric(const ValueMetric& vm) {
|
|
string result;
|
|
if (vm.has_error_code()) {
|
|
result.append("error(" + to_string(vm.error_code()));
|
|
result.append(FormatCdmErrorTranslation(vm.error_code()));
|
|
result.append(")");
|
|
}
|
|
if (vm.has_int_value()) {
|
|
result.append(to_string(vm.int_value()));
|
|
}
|
|
if (vm.has_double_value()) {
|
|
std::ostringstream buffer;
|
|
buffer << vm.double_value();
|
|
result.append(buffer.str());
|
|
}
|
|
if (vm.has_string_value()) {
|
|
result.append("\"");
|
|
result.append(vm.string_value());
|
|
result.append("\"");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#define FORMAT_REPEATED_DISTRIBUTION(NAME, INDENT) \
|
|
if (metrics.NAME##_size() == 1) { \
|
|
result.append(INDENT + #NAME + ": "); \
|
|
result.append(FormatDistributionMetric(metrics.NAME(0)) + "\n"); \
|
|
} else { \
|
|
for (int i = 0; i < metrics.NAME##_size(); i++) { \
|
|
result.append(INDENT + #NAME "[" + to_string(i) + "]: "); \
|
|
result.append(FormatDistributionMetric(metrics.NAME(i)) + "\n"); \
|
|
} \
|
|
}
|
|
|
|
#define FORMAT_REPEATED_COUNTER(NAME, INDENT) \
|
|
if (metrics.NAME##_size() == 1) { \
|
|
result.append(INDENT + #NAME ": "); \
|
|
result.append(FormatCounterMetric(metrics.NAME(0)) + "\n"); \
|
|
} else { \
|
|
for (int i = 0; i < metrics.NAME##_size(); i++) { \
|
|
result.append(INDENT + #NAME "[" + to_string(i) + "]: "); \
|
|
result.append(FormatCounterMetric(metrics.NAME(i)) + "\n"); \
|
|
} \
|
|
}
|
|
|
|
#define FORMAT_OPTIONAL_VALUE(NAME, INDENT) \
|
|
if (metrics.has_##NAME()) { \
|
|
result.append(INDENT + #NAME ": " + FormatValueMetric(metrics.NAME()) + \
|
|
"\n"); \
|
|
}
|
|
|
|
#define FORMAT_OPTIONAL_INITIALIZATION_MODE(NAME, INDENT) \
|
|
if (metrics.has_##NAME()) { \
|
|
result.append(INDENT + #NAME ": "); \
|
|
result.append(FormatOEMCryptoInitializeMode(metrics.NAME()) + "\n"); \
|
|
}
|
|
|
|
#define FORMAT_OPTIONAL_HDCP_CAPABILITY(NAME, INDENT) \
|
|
if (metrics.has_##NAME()) { \
|
|
result.append(INDENT + #NAME ": "); \
|
|
result.append(FormatOEMCryptoHdcpCapability(metrics.NAME()) + "\n"); \
|
|
}
|
|
|
|
#define FORMAT_OPTIONAL_PROVISIONING_METHOD(NAME, INDENT) \
|
|
if (metrics.has_##NAME()) { \
|
|
result.append(INDENT + #NAME ": "); \
|
|
result.append(FormatOEMCryptoProvisioningMethod(metrics.NAME()) + "\n"); \
|
|
}
|
|
|
|
#define FORMAT_OPTIONAL_CRYPTO_METRICS(NAME, INDENT) \
|
|
if (metrics.has_##NAME()) { \
|
|
FormatCryptoMetrics(metrics.NAME(), INDENT + kIndentPerLine, result); \
|
|
}
|
|
|
|
void FormatCryptoMetrics(const WvCdmMetrics_CryptoMetrics metrics,
|
|
const string& indent, string& result) {
|
|
// Crypto Session Metrics.
|
|
FORMAT_OPTIONAL_VALUE(crypto_session_security_level, indent);
|
|
FORMAT_REPEATED_COUNTER(crypto_session_delete_all_usage_reports, indent);
|
|
FORMAT_REPEATED_COUNTER(crypto_session_delete_multiple_usage_information,
|
|
indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(crypto_session_generic_decrypt_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(crypto_session_generic_encrypt_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(crypto_session_generic_sign_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(crypto_session_generic_verify_time_us, indent);
|
|
FORMAT_REPEATED_COUNTER(crypto_session_get_device_unique_id, indent);
|
|
FORMAT_REPEATED_COUNTER(crypto_session_get_token, indent);
|
|
FORMAT_OPTIONAL_VALUE(crypto_session_life_span, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(
|
|
crypto_session_load_certificate_private_key_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(crypto_session_open_time_us, indent);
|
|
FORMAT_OPTIONAL_VALUE(crypto_session_system_id, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(crypto_session_update_usage_information_time_us,
|
|
indent);
|
|
FORMAT_OPTIONAL_VALUE(crypto_session_usage_information_support, indent);
|
|
|
|
// Usage Table Metrics
|
|
FORMAT_OPTIONAL_VALUE(usage_table_header_initial_size, indent);
|
|
FORMAT_REPEATED_COUNTER(usage_table_header_add_entry, indent);
|
|
FORMAT_REPEATED_COUNTER(usage_table_header_delete_entry, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(usage_table_header_update_entry_time_us, indent);
|
|
FORMAT_REPEATED_COUNTER(usage_table_header_load_entry, indent);
|
|
|
|
// Usage Table LRU Metrics
|
|
FORMAT_OPTIONAL_VALUE(usage_table_header_lru_usage_info_count, indent);
|
|
FORMAT_OPTIONAL_VALUE(usage_table_header_lru_offline_license_count, indent);
|
|
FORMAT_OPTIONAL_VALUE(usage_table_header_lru_evicted_entry_staleness_s,
|
|
indent);
|
|
|
|
// |usage_table_header_lru_evicted_entry_type| refers to the enumeration
|
|
// CdmUsageEntryStorageType in wv_cdm_types.h.
|
|
FORMAT_OPTIONAL_VALUE(usage_table_header_lru_evicted_entry_type, indent);
|
|
|
|
// OemCrypto metrics.
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_api_version, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_close_session, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_copy_buffer_time_us, indent);
|
|
FORMAT_OPTIONAL_HDCP_CAPABILITY(oemcrypto_current_hdcp_capability, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_deactivate_usage_entry, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_decrypt_cenc_time_us, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_delete_usage_entry, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_delete_usage_table, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_derive_keys_from_session_key_time_us,
|
|
indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_force_delete_usage_entry, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_generate_derived_keys_time_us, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_generate_nonce, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_generate_rsa_signature_time_us,
|
|
indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_generate_signature_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_generic_decrypt_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_generic_encrypt_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_generic_sign_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_generic_verify_time_us, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_get_device_id, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_get_key_data_time_us, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_get_oem_public_certificate, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_get_random, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_initialize_time_us, indent);
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_is_anti_rollback_hw_present, indent);
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_is_keybox_valid, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_load_device_drm_key_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_load_entitled_keys_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_load_keys_time_us, indent);
|
|
FORMAT_OPTIONAL_HDCP_CAPABILITY(oemcrypto_max_hdcp_capability, indent);
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_max_number_of_sessions, indent);
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_number_of_open_sessions, indent);
|
|
FORMAT_OPTIONAL_PROVISIONING_METHOD(oemcrypto_provisioning_method, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_refresh_keys_time_us, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_report_usage, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_rewrap_device_rsa_key_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_rewrap_device_rsa_key_30_time_us,
|
|
indent);
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_security_patch_level, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_select_key_time_us, indent);
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_usage_table_support, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_update_usage_table, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_update_usage_entry, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_create_usage_table_header, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_load_usage_table_header, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_shrink_usage_table_header, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_create_new_usage_entry, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_load_usage_entry, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_move_entry, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_create_old_usage_entry, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_copy_old_usage_entry, indent);
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_set_sandbox, indent);
|
|
FORMAT_REPEATED_COUNTER(oemcrypto_set_decrypt_hash, indent);
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_resource_rating_tier, indent);
|
|
|
|
// Oemcrypto V16 metrics below
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_prep_and_sign_license_request_time_us,
|
|
indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_prep_and_sign_renewal_request_time_us,
|
|
indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(
|
|
oemcrypto_prep_and_sign_provisioning_request_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_load_license_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_load_renewal_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(oemcrypto_load_provisioning_time_us, indent);
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_minor_api_version, indent);
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_maximum_usage_table_header_size, indent);
|
|
|
|
// OEMCrypto V17 metrics below.
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_watermarking_support, indent);
|
|
}
|
|
|
|
void FormatSessionMetrics(const WvCdmMetrics_SessionMetrics& metrics,
|
|
const string& indent, string& result) {
|
|
FORMAT_OPTIONAL_VALUE(session_id, indent);
|
|
FORMAT_OPTIONAL_CRYPTO_METRICS(crypto_metrics, indent);
|
|
FORMAT_OPTIONAL_VALUE(cdm_session_life_span_ms, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(cdm_session_renew_key_time_us, indent);
|
|
FORMAT_REPEATED_COUNTER(cdm_session_restore_offline_session, indent);
|
|
FORMAT_REPEATED_COUNTER(cdm_session_restore_usage_session, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(cdm_session_license_request_latency_ms, indent);
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_build_info, indent);
|
|
FORMAT_OPTIONAL_VALUE(license_sdk_version, indent);
|
|
FORMAT_OPTIONAL_VALUE(license_service_version, indent);
|
|
}
|
|
|
|
void FormatEngineMetrics(const WvCdmMetrics_EngineMetrics& metrics,
|
|
const string& indent, string& result) {
|
|
FORMAT_OPTIONAL_CRYPTO_METRICS(crypto_metrics, indent);
|
|
|
|
// OEMCrypto Initialize Metrics.
|
|
FORMAT_OPTIONAL_INITIALIZATION_MODE(oemcrypto_initialization_mode, indent);
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_l1_api_version, indent);
|
|
FORMAT_OPTIONAL_VALUE(oemcrypto_l1_min_api_version, indent);
|
|
FORMAT_OPTIONAL_VALUE(level3_oemcrypto_initialization_error, indent);
|
|
FORMAT_OPTIONAL_VALUE(previous_oemcrypto_initialization_failure, indent);
|
|
|
|
// CdmEngine Metrics.
|
|
FORMAT_OPTIONAL_VALUE(app_package_name, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(cdm_engine_add_key_time_us, indent);
|
|
FORMAT_OPTIONAL_VALUE(cdm_engine_cdm_version, indent);
|
|
FORMAT_REPEATED_COUNTER(cdm_engine_close_session, indent);
|
|
FORMAT_OPTIONAL_VALUE(cdm_engine_creation_time_millis, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(cdm_engine_decrypt_time_us, indent);
|
|
FORMAT_REPEATED_COUNTER(cdm_engine_find_session_for_key, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(cdm_engine_generate_key_request_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(cdm_engine_get_provisioning_request_time_us,
|
|
indent);
|
|
FORMAT_REPEATED_COUNTER(cdm_engine_get_secure_stop_ids, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(cdm_engine_get_usage_info_time_us, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(cdm_engine_handle_provisioning_response_time_us,
|
|
indent);
|
|
FORMAT_OPTIONAL_VALUE(cdm_engine_life_span_ms, indent);
|
|
FORMAT_REPEATED_COUNTER(cdm_engine_open_key_set_session, indent);
|
|
FORMAT_REPEATED_COUNTER(cdm_engine_open_session, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(cdm_engine_query_key_status_time_us, indent);
|
|
FORMAT_REPEATED_COUNTER(cdm_engine_release_all_usage_info, indent);
|
|
FORMAT_REPEATED_COUNTER(cdm_engine_release_usage_info, indent);
|
|
FORMAT_REPEATED_COUNTER(cdm_engine_remove_all_usage_info, indent);
|
|
FORMAT_REPEATED_COUNTER(cdm_engine_remove_keys, indent);
|
|
FORMAT_REPEATED_COUNTER(cdm_engine_remove_usage_info, indent);
|
|
FORMAT_REPEATED_DISTRIBUTION(cdm_engine_restore_key_time_us, indent);
|
|
FORMAT_REPEATED_COUNTER(cdm_engine_unprovision, indent);
|
|
}
|
|
} // anonymous namespace
|
|
|
|
namespace wv_metrics {
|
|
void FormatWvCdmMetrics(const WvCdmMetrics& metrics, string& result) {
|
|
string indent = kIndentPerLine;
|
|
string next_indent = indent + kIndentPerLine;
|
|
|
|
result.append("engine_metrics\n");
|
|
if (metrics.has_engine_metrics()) {
|
|
FormatEngineMetrics(metrics.engine_metrics(), indent, result);
|
|
}
|
|
result.append("session_metrics\n");
|
|
for (int i = 0; i < metrics.session_metrics_size(); i++) {
|
|
result.append(indent + "session[" + to_string(i) + "]\n");
|
|
FormatSessionMetrics(metrics.session_metrics(i), next_indent, result);
|
|
}
|
|
}
|
|
} // namespace wv_metrics
|