Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f0e618d0 authored by Adam Stone's avatar Adam Stone
Browse files

Add EventMetric and a single use case. 

Adds an EventMetric class, associated unit tests, and an instance of the
EventMetric to DrmHal. Also added a unit test for CounterMetric and
created a class to hold all of the future metric instances.

BUG: 64001676

Test: Added and ran unit tests.  Also added a CTS test case.
Change-Id: Ic94bedd5f8293a58a939613a4ae69ce656a772be
parent 38428ce1

drm/libmediadrm/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ cc_library { 
        "PluginMetricsReporting.cpp",

        "SharedLibrary.cpp",

        "DrmHal.cpp",

	"DrmMetrics.cpp",

        "CryptoHal.cpp",

        "protos/plugin_metrics.proto",

    ],

drm/libmediadrm/DrmHal.cpp

+13 −23
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ 
#include <media/DrmHal.h>

#include <media/DrmSessionClientInterface.h>

#include <media/DrmSessionManager.h>

#include <media/EventMetric.h>

#include <media/PluginMetricsReporting.h>

#include <media/drm/DrmAPI.h>

#include <media/stagefright/foundation/ADebug.h>
@@ -227,7 +228,6 @@ private: 
DrmHal::DrmHal()

   : mDrmSessionClient(new DrmSessionClient(this)),

     mFactories(makeDrmFactories()),

     mOpenSessionCounter("/drm/mediadrm/open_session", "status"),

     mInitCheck((mFactories.size() == 0) ? ERROR_UNSUPPORTED : NO_INIT) {

}
@@ -519,7 +519,7 @@ status_t DrmHal::openSession(Vector<uint8_t> &sessionId) { 
        mOpenSessions.push(sessionId);

    }



    mOpenSessionCounter.Increment(err);

    mMetrics.mOpenSessionCounter.Increment(err);

    return err;

}
@@ -551,6 +551,7 @@ status_t DrmHal::getKeyRequest(Vector<uint8_t> const &sessionId, 
        String8 &defaultUrl, DrmPlugin::KeyRequestType *keyRequestType) {

    Mutex::Autolock autoLock(mLock);

    INIT_CHECK();

    EventTimer<status_t> keyRequestTimer(&mMetrics.mGetKeyRequestTiming);



    DrmSessionManager::Instance()->useSession(sessionId);
@@ -562,6 +563,7 @@ status_t DrmHal::getKeyRequest(Vector<uint8_t> const &sessionId, 
    } else if (keyType == DrmPlugin::kKeyType_Release) {

        hKeyType = KeyType::RELEASE;

    } else {

        keyRequestTimer.SetAttribute(BAD_VALUE);

        return BAD_VALUE;

    }
@@ -636,7 +638,9 @@ status_t DrmHal::getKeyRequest(Vector<uint8_t> const &sessionId, 
                }

            });



    return hResult.isOk() ? err : DEAD_OBJECT;

    err = hResult.isOk() ? err : DEAD_OBJECT;

    keyRequestTimer.SetAttribute(err);

    return err;

}



status_t DrmHal::provideKeyResponse(Vector<uint8_t> const &sessionId,
@@ -987,26 +991,12 @@ status_t DrmHal::setPropertyByteArray(String8 const &name, 
    return toStatusT(status);

}



status_t DrmHal::getMetrics(MediaAnalyticsItem* metrics) {

    // TODO: Move mOpenSessionCounter and suffixes to a separate class

    // that manages the collection of metrics and exporting them.

    std::string success_count_name =

        mOpenSessionCounter.metric_name() + "/ok/count";

    std::string error_count_name =

        mOpenSessionCounter.metric_name() + "/error/count";

    mOpenSessionCounter.ExportValues(

        [&] (status_t status, int64_t value) {

            if (status == OK) {

                metrics->setInt64(success_count_name.c_str(), value);

            } else {

                int64_t total_errors(0);

                metrics->getInt64(error_count_name.c_str(), &total_errors);

                metrics->setInt64(error_count_name.c_str(),

                                  total_errors + value);

                // TODO: Add support for exporting the list of error values.

                // This probably needs to be added to MediaAnalyticsItem.

status_t DrmHal::getMetrics(MediaAnalyticsItem* item) {

    if (item == nullptr) {

      return UNEXPECTED_NULL;

    }

        });



    mMetrics.Export(item);

    return OK;

}

drm/libmediadrm/DrmMetrics.cpp

0 → 100644
+77 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2018 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <media/DrmMetrics.h>



namespace {



template<typename T>

void ExportCounterMetric(const android::CounterMetric<T>& counter,

                         android::MediaAnalyticsItem* item) {

  std::string success_count_name = counter.metric_name() + "/ok/count";

  std::string error_count_name = counter.metric_name() + "/error/count";

  counter.ExportValues(

      [&] (const android::status_t status, const int64_t value) {

          if (status == android::OK) {

              item->setInt64(success_count_name.c_str(), value);

          } else {

              int64_t total_errors(0);

              item->getInt64(error_count_name.c_str(), &total_errors);

              item->setInt64(error_count_name.c_str(), total_errors + value);

              // TODO: Add support for exporting the list of error values.

              // This probably needs to be added to MediaAnalyticsItem.

          }

      });

}



template<typename T>

void ExportEventMetric(const android::EventMetric<T>& event,

                       android::MediaAnalyticsItem* item) {

  std::string success_count_name = event.metric_name() + "/ok/count";

  std::string error_count_name = event.metric_name() + "/error/count";

  std::string timing_name = event.metric_name() + "/average_time_micros";

  event.ExportValues(

      [&] (const android::status_t& status,

           const android::EventStatistics& value) {

          if (status == android::OK) {

              item->setInt64(success_count_name.c_str(), value.count);

              item->setInt64(timing_name.c_str(), value.mean);

          } else {

              int64_t total_errors(0);

              item->getInt64(error_count_name.c_str(), &total_errors);

              item->setInt64(error_count_name.c_str(),

                             total_errors + value.count);

              // TODO: Add support for exporting the list of error values.

              // This probably needs to be added to MediaAnalyticsItem.

          }

      });

}



}  // namespace anonymous



namespace android {



MediaDrmMetrics::MediaDrmMetrics()

    : mOpenSessionCounter("/drm/mediadrm/open_session", "status"),

      mGetKeyRequestTiming("/drm/mediadrm/get_key_request", "status") {

}



void MediaDrmMetrics::Export(MediaAnalyticsItem* item) {

  ExportCounterMetric(mOpenSessionCounter, item);

  ExportEventMetric(mGetKeyRequestTiming, item);

}



}  // namespace android

drm/libmediadrm/tests/Android.bp

+15 −0
Original line number Diff line number Diff line
@@ -10,3 +10,18 @@ cc_test { 
      "-Wall",

    ],

}



cc_test {

    name: "EventMetric_test",

    srcs: ["EventMetric_test.cpp"],

    shared_libs: [

      "liblog",

      "libmediadrm",

      "libutils",

    ],

    include_dirs: ["frameworks/av/include/media"],

    cflags: [

      "-Werror",

      "-Wall",

    ],

}

drm/libmediadrm/tests/EventMetric_test.cpp

0 → 100644
+142 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2018 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <gtest/gtest.h>



#include "EventMetric.h"



namespace android {



/**

 * Unit tests for the EventMetric class.

 */



TEST(EventMetricTest, IntDataTypeEmpty) {

  EventMetric<int> metric("MyMetricName", "MetricAttributeName");



  std::map<int, EventStatistics> values;



  metric.ExportValues(

      [&] (int attribute_value, const EventStatistics& value) {

          values[attribute_value] = value;

      });



  EXPECT_TRUE(values.empty());

}



TEST(EventMetricTest, IntDataType) {

  EventMetric<int> metric("MyMetricName", "MetricAttributeName");



  std::map<int, EventStatistics> values;



  metric.Record(4, 7);

  metric.Record(5, 8);

  metric.Record(5, 8);

  metric.Record(5, 8);

  metric.Record(6, 8);

  metric.Record(6, 8);

  metric.Record(6, 8);



  metric.ExportValues(

      [&] (int attribute_value, const EventStatistics& value) {

          values[attribute_value] = value;

      });



  ASSERT_EQ(2u, values.size());

  EXPECT_EQ(4, values[7].min);

  EXPECT_EQ(4, values[7].max);

  EXPECT_EQ(4, values[7].mean);

  EXPECT_EQ(1, values[7].count);



  EXPECT_EQ(5, values[8].min);

  EXPECT_EQ(6, values[8].max);

  // This is an approximate value because of the technique we're using.

  EXPECT_NEAR(5.5, values[8].mean, 0.2);

  EXPECT_EQ(6, values[8].count);

}



TEST(EventMetricTest, StringDataType) {

  EventMetric<std::string> metric("MyMetricName", "MetricAttributeName");



  std::map<std::string, EventStatistics> values;



  metric.Record(1, "a");

  metric.Record(2, "b");

  metric.Record(2, "b");

  metric.Record(3, "b");

  metric.Record(3, "b");



  metric.ExportValues(

      [&] (std::string attribute_value, const EventStatistics& value) {

          values[attribute_value] = value;

      });



  ASSERT_EQ(2u, values.size());

  EXPECT_EQ(1, values["a"].min);

  EXPECT_EQ(1, values["a"].max);

  EXPECT_EQ(1, values["a"].mean);

  EXPECT_EQ(1, values["a"].count);



  EXPECT_EQ(2, values["b"].min);

  EXPECT_EQ(3, values["b"].max);

  EXPECT_NEAR(2.5, values["b"].mean, 0.2);

  EXPECT_EQ(4, values["b"].count);

}



// Helper class that allows us to mock the clock.

template<typename AttributeType>

class MockEventTimer : public EventTimer<AttributeType> {

 public:

  explicit MockEventTimer(nsecs_t time_delta_ns,

                          EventMetric<AttributeType>* metric)

      : EventTimer<AttributeType>(metric) {

    // Pretend the event started earlier.

    this->start_time_ = systemTime() - time_delta_ns;

  }

};



TEST(EventTimerTest, IntDataType) {

  EventMetric<int> metric("MyMetricName", "MetricAttributeName");



  for (int i = 0; i < 5; i++) {

    {

      // Add a mock time delta.

      MockEventTimer<int> metric_timer(i * 1000000, &metric);

      metric_timer.SetAttribute(i % 2);

    }

  }



  std::map<int, EventStatistics> values;

  metric.ExportValues(

      [&] (int attribute_value, const EventStatistics& value) {

          values[attribute_value] = value;

      });



  ASSERT_EQ(2u, values.size());

  EXPECT_LT(values[0].min, values[0].max);

  EXPECT_GE(4000, values[0].max);

  EXPECT_GT(values[0].mean, values[0].min);

  EXPECT_LE(values[0].mean, values[0].max);

  EXPECT_EQ(3, values[0].count);



  EXPECT_LT(values[1].min, values[1].max);

  EXPECT_GE(3000, values[1].max);

  EXPECT_GT(values[1].mean, values[1].min);

  EXPECT_LE(values[1].mean, values[1].max);

  EXPECT_EQ(2, values[1].count);

}



}  // namespace android