tree 8a6552e3bf6b6d8e8bbb78c2d9b7938716563410
parent 5c18c4f31bb2185179222c027bbc4adb8aacc708
author Francois Rousseau <frousseau@google.com> 1634252273 +0000
committer releases-try-builder <releases-try-builder@fuchsia-infra.iam.gserviceaccount.com> 1634260089 +0000

[local_storage] new data_partition_upgrade metric

* Sampler is sending an Occurrence so the metric type should be
  EVENT_COUNT – going with a new metric ID to be safer
* this still requires fshost to change its Inspect field type and
  the Sampler config to be changed to the new metric ID in
  fxrev.dev/594241
* fix the report name that's redundant with the metric name

TESTED=Cobalt no longer complaining about the metric type

Bug: 86635
Change-Id: Ia400d5aecf253f309971a721e1f5ab8544821119
Reviewed-on: https://fuchsia-review.googlesource.com/c/cobalt-registry/+/594148
Reviewed-by: Steve Fung <stevefung@google.com>
Reviewed-by: Zach Bush <zmbush@google.com>
Privacy-Approval: Steve Fung <stevefung@google.com>
Commit-Queue: Francois Rousseau <frousseau@google.com>
