widevine-partner/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Output metrics in YAML format

Browse Source 
Merge from http://go/wvgerrit/158917

Use go/yamllint as reference and obfuscate portion of output to
run on an online yaml validator.

Sample output: http://go/cl/481370906

Test: Netflix, Play TV and Movies, Youtube
Test: adb shell dumpsys android.hardware.drm.IDrmFactory/widevine
Test: ./build_and_run_all_unit_tests.sh

Bug: 239462891
Change-Id: I1abf1aa50aa25b97b1f6c10995c324d6de04d056
This commit is contained in:
Edwin Wong
2022-10-16 20:31:42 +00:00
parent 3cfe7c7299
commit c70e3deb8b
8 changed files with 1036 additions and 1303 deletions
Download Patch File Download Diff File Expand all files Collapse all files

249
libwvdrmengine/src/wv_metrics.cpp
View File

@@ -12,26 +12,104 @@
#include <sstream>
#include <string>
#include <aidl/android/hardware/drm/Status.h>
#include "OEMCryptoCENC.h"
#include "error_string_util.h"
#include "wv_cdm_types.h"
using namespace drm_metrics;
using ::aidl::android::hardware::drm::Status;
using std::string;
using std::to_string;
namespace {
const string kIndentPerLine = " ";
const string kIndentSpaces = " ";
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();
const string DrmHalStatusToString(Status hal_status) {
switch (hal_status) {
case Status::OK:
return "OK";
case Status::ERROR_DRM_NO_LICENSE:
return "ERROR_DRM_NO_LICENSE";
case Status::ERROR_DRM_LICENSE_EXPIRED:
return "ERROR_DRM_LICENSE_EXPIRED";
case Status::ERROR_DRM_SESSION_NOT_OPENED:
return "ERROR_DRM_SESSION_NOT_OPENED";
case Status::ERROR_DRM_CANNOT_HANDLE:
return "ERROR_DRM_CANNOT_HANDLE";
case Status::ERROR_DRM_INVALID_STATE:
return "ERROR_DRM_INVALID_STATE,";
case Status::BAD_VALUE:
return "BAD_VALUE";
case Status::ERROR_DRM_NOT_PROVISIONED:
return "ERROR_DRM_NOT_PROVISIONED";
case Status::ERROR_DRM_RESOURCE_BUSY:
return "ERROR_DRM_RESOURCE_BUSY";
case Status::ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION:
return "ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION";
case Status::ERROR_DRM_DEVICE_REVOKED:
return "ERROR_DRM_DEVICE_REVOKED";
case Status::ERROR_DRM_DECRYPT:
return "ERROR_DRM_DECRYPT";
case Status::ERROR_DRM_UNKNOWN:
return "ERROR_DRM_UNKNOWN";
case Status::ERROR_DRM_INSUFFICIENT_SECURITY:
return "ERROR_DRM_INSUFFICIENT_SECURITY";
case Status::ERROR_DRM_FRAME_TOO_LARGE:
return "ERROR_DRM_FRAME_TOO_LARGE";
case Status::ERROR_DRM_SESSION_LOST_STATE:
return "ERROR_DRM_SESSION_LOST_STATE";
case Status::ERROR_DRM_RESOURCE_CONTENTION:
return "ERROR_DRM_RESOURCE_CONTENTION";
case Status::CANNOT_DECRYPT_ZERO_SUBSAMPLES:
return "CANNOT_DECRYPT_ZERO_SUBSAMPLES";
case Status::CRYPTO_LIBRARY_ERROR:
return "CRYPTO_LIBRARY_ERROR";
case Status::GENERAL_OEM_ERROR:
return "GENERAL_OEM_ERROR";
case Status::GENERAL_PLUGIN_ERROR:
return "GENERAL_PLUGIN_ERROR";
case Status::INIT_DATA_INVALID:
return "INIT_DATA_INVALID";
case Status::KEY_NOT_LOADED:
return "KEY_NOT_LOADED";
case Status::LICENSE_PARSE_ERROR:
return "LICENSE_PARSE_ERROR";
case Status::LICENSE_POLICY_ERROR:
return "LICENSE_POLICY_ERROR";
case Status::LICENSE_RELEASE_ERROR:
return "LICENSE_RELEASE_ERROR";
case Status::LICENSE_REQUEST_REJECTED:
return "LICENSE_REQUEST_REJECTED";
case Status::LICENSE_RESTORE_ERROR:
return "LICENSE_RESTORE_ERROR";
case Status::LICENSE_STATE_ERROR:
return "LICENSE_STATE_ERROR";
case Status::MALFORMED_CERTIFICATE:
return "MALFORMED_CERTIFICATE";
case Status::MEDIA_FRAMEWORK_ERROR:
return "MEDIA_FRAMEWORK_ERROR";
case Status::MISSING_CERTIFICATE:
return "MISSING_CERTIFICATE";
case Status::PROVISIONING_CERTIFICATE_ERROR:
return "PROVISIONING_CERTIFICATE_ERROR";
case Status::PROVISIONING_CONFIGURATION_ERROR:
return "PROVISIONING_CONFIGURATION_ERROR";
case Status::PROVISIONING_PARSE_ERROR:
return "PROVISIONING_PARSE_ERROR";
case Status::PROVISIONING_REQUEST_REJECTED:
return "PROVISIONING_REQUEST_REJECTED";
case Status::RETRYABLE_PROVISIONING_ERROR:
return "RETRYABLE_PROVISIONING_ERROR";
case Status::SECURE_STOP_RELEASE_ERROR:
return "SECURE_STOP_RELEASE_ERROR";
case Status::STORAGE_READ_FAILURE:
return "STORAGE_READ_FAILURE";
case Status::STORAGE_WRITE_FAILURE:
return "STORAGE_WRITE_FAILURE";
default:
return "Invalid Drm HAL status.";
}
}
string FormatOEMCryptoInitializeMode(const ValueMetric& vm) {
@@ -76,118 +154,129 @@ string FormatOEMCryptoProvisioningMethod(const ValueMetric& vm) {
return translations[vm.int_value()];
}
string FormatAttributes(const Attributes& attributes) {
string FormatAttributes(const string& indent, const Attributes& attributes) {
string result;
if (attributes.has_error_code()) {
result.append("error_code:");
result.assign(indent);
result.append("error_code:\n");
string next_indent = indent + kIndentSpaces;
result.append(next_indent + "name: ");
result.append(DrmHalStatusToString(static_cast<Status>(attributes.error_code())));
result.append("\n" + next_indent + "value: ");
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.assign(indent);
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.assign(indent);
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.assign(indent);
result.append("security_level: ");
result.append(to_string(attributes.security_level()));
}
if (attributes.has_length()) {
if (result.size()) result.append(",");
result.append("length:");
result.assign(indent);
result.append("length: ");
result.append(to_string(attributes.length()));
}
if (attributes.has_encryption_algorithm()) {
if (result.size()) result.append(",");
result.append("encryption_algorithm:");
result.assign(indent);
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.assign(indent);
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.assign(indent);
result.append("oemcrypto_result:\n");
string next_indent = indent + kIndentSpaces;
result.append(next_indent + "name: ");
result.append(::wvutil::OEMCryptoResultToString(attributes.oem_crypto_result()));
result.append("\n" + next_indent + "value: ");
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.assign(indent);
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.assign(indent);
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.assign(indent);
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.assign(indent);
result.append("license_type: ");
result.append(to_string(attributes.license_type()));
}
if (result.size()) {
return string(" {") + result + "}";
return result;
} else {
return "";
return " null";
}
}
string FormatCounterMetric(const CounterMetric& cm) {
string result;
string FormatCounterMetric(const string& indent, const CounterMetric& cm) {
string result(indent + kIndentSpaces);
if (cm.has_count()) {
result = string("count=") + to_string(cm.count());
result.append(string("count: ") + to_string(cm.count()) + "\n");
if (cm.has_attributes()) {
result.append(FormatAttributes(cm.attributes()));
string newIndent(indent + kIndentSpaces);
result.append(FormatAttributes(newIndent, cm.attributes()));
}
}
return result;
}
string FormatDistributionMetric(const DistributionMetric& dm) {
string FormatDistributionMetric(const string& indent, const DistributionMetric& dm) {
string result;
if (dm.has_min()) {
std::ostringstream buffer;
buffer << dm.min();
result = string("min=") + buffer.str();
result.append(indent + kIndentSpaces);
result.append(string("min: ") + buffer.str() + "\n");
}
if (dm.has_max()) {
std::ostringstream buffer;
buffer << dm.max();
if (result.size()) result.append(" ");
result += string("max=") + buffer.str();
result.append(indent + kIndentSpaces);
result.append(string("max: ") + buffer.str() + "\n");
}
if (dm.has_mean()) {
std::ostringstream buffer;
buffer << dm.mean();
if (result.size()) result.append(" ");
result += string("mean=") + buffer.str();
result.append(indent + kIndentSpaces);
result.append(string("mean: ") + buffer.str() + "\n");
}
if (dm.has_variance()) {
std::ostringstream buffer;
buffer << dm.variance();
if (result.size()) result.append(" ");
result += string("variance=") + buffer.str();
result.append(indent + kIndentSpaces);
result.append(string("variance: ") + buffer.str() + "\n");
}
if (dm.has_operation_count()) {
if (result.size()) result.append(" ");
result += string("count=") + to_string(dm.operation_count());
result.append(indent + kIndentSpaces);
result.append(string("count: ") + to_string(dm.operation_count()) + "\n");
}
if (dm.has_attributes()) {
result.append(FormatAttributes(dm.attributes()));
string newIndent(indent + kIndentSpaces);
result.append(FormatAttributes(newIndent, dm.attributes()));
}
return result;
}
@@ -195,9 +284,11 @@ string FormatDistributionMetric(const DistributionMetric& dm) {
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(")");
result.append("error_code:\n");
result.append(kIndentSpaces + "name: ");
result.append(DrmHalStatusToString(static_cast<Status>(vm.error_code())));
result.append("\n" + kIndentSpaces + "value: ");
result.append(to_string(vm.error_code()));
}
if (vm.has_int_value()) {
result.append(to_string(vm.int_value()));
@@ -208,32 +299,31 @@ string FormatValueMetric(const ValueMetric& vm) {
result.append(buffer.str());
}
if (vm.has_string_value()) {
result.append("\"");
result.append(vm.string_value());
result.append("\"");
result.append("\"" + vm.string_value() + "\"");
}
return result;
}
#define FORMAT_REPEATED_DISTRIBUTION(NAME, INDENT) \
if (metrics.NAME##_size() == 1) { \
result.append(INDENT + #NAME + ": "); \
result.append(FormatDistributionMetric(metrics.NAME(0)) + "\n"); \
result.append(INDENT + #NAME + ":\n"); \
result.append(FormatDistributionMetric(INDENT, 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"); \
result.append(INDENT + #NAME "[" + to_string(i) + "]:\n"); \
result.append(FormatDistributionMetric(INDENT, 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"); \
result.append(INDENT + #NAME ":\n"); \
result.append(FormatCounterMetric(INDENT, 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"); \
result.append(INDENT + #NAME "[" + to_string(i) + "]: [\n"); \
result.append(FormatCounterMetric(INDENT, metrics.NAME(i)) + "\n"); \
result.append("]\n"); \
} \
}
@@ -263,7 +353,7 @@ string FormatValueMetric(const ValueMetric& vm) {
#define FORMAT_OPTIONAL_CRYPTO_METRICS(NAME, INDENT) \
if (metrics.has_##NAME()) { \
FormatCryptoMetrics(metrics.NAME(), INDENT + kIndentPerLine, result); \
FormatCryptoMetrics(metrics.NAME(), INDENT, result); \
}
void FormatCryptoMetrics(const WvCdmMetrics_CryptoMetrics metrics,
@@ -435,17 +525,24 @@ void FormatEngineMetrics(const WvCdmMetrics_EngineMetrics& metrics,
namespace wv_metrics {
void FormatWvCdmMetrics(const WvCdmMetrics& metrics, string& result) {
string indent = kIndentPerLine;
string next_indent = indent + kIndentPerLine;
string indent = kIndentSpaces + kIndentSpaces + kIndentSpaces;
string next_indent = indent + kIndentSpaces;
result.append("engine_metrics\n");
result.append(kIndentSpaces + " engine_metrics:");
if (metrics.has_engine_metrics()) {
result.append("\n");
FormatEngineMetrics(metrics.engine_metrics(), indent, result);
} else {
result.append(" null\n");
}
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);
result.append(kIndentSpaces + " session_metrics:");
if (metrics.session_metrics_size()) {
for (int i = 0; i < metrics.session_metrics_size(); i++) {
result.append("\n" + indent + "session[" + to_string(i) + "]:\n");
FormatSessionMetrics(metrics.session_metrics(i), next_indent, result);
}
} else {
result.append(" null\n");
}
}
} // namespace wv_metrics