diff --git a/src/lib/clearcut/uploader.cc b/src/lib/clearcut/uploader.cc
index 184e7db..af02c9d 100644
--- a/src/lib/clearcut/uploader.cc
+++ b/src/lib/clearcut/uploader.cc
@@ -104,7 +104,7 @@
 
     escaped_request_body = absl::CEscape(request.body);
     request_body_size = request.body.size();
-    internal_metrics_->BytesUploaded(logger::PerDeviceBytesUploadedMetricDimensionStatus::Attempted,
+    internal_metrics_->BytesUploaded(logger::BytesUploadedMetricDimensionStatus::Attempted,
                                      request_body_size);
 
     VLOG(5) << "ClearcutUploader: Sending POST request to " << url_ << ".";
@@ -165,7 +165,7 @@
     }
   }
 
-  internal_metrics_->BytesUploaded(logger::PerDeviceBytesUploadedMetricDimensionStatus::Succeeded,
+  internal_metrics_->BytesUploaded(logger::BytesUploadedMetricDimensionStatus::Succeeded,
                                    request_body_size);
 
   LogResponse log_response;
diff --git a/src/logger/BUILD.gn b/src/logger/BUILD.gn
index 830ad56..87b3b05 100644
--- a/src/logger/BUILD.gn
+++ b/src/logger/BUILD.gn
@@ -163,6 +163,7 @@
     "$cobalt_root/src:logging",
     "$cobalt_root/src/lib/util:protected_fields",
     "$cobalt_root/src/public:diagnostics_interface",
+    "$cobalt_root/src/public/lib:registry_identifiers",
     "//third_party/abseil-cpp",
   ]
 }
@@ -440,6 +441,7 @@
     ":internal_metrics",
     ":logger_test_utils",
     "$cobalt_root/src/local_aggregation:cobalt_local_aggregation_proto",
+    "$cobalt_root/src/public/lib:registry_identifiers",
     "//third_party/abseil-cpp",
     "//third_party/googletest:gtest",
     "//third_party/tink/cc/util:status",
diff --git a/src/logger/fake_logger.h b/src/logger/fake_logger.h
index 53e3517..9b3fb87 100644
--- a/src/logger/fake_logger.h
+++ b/src/logger/fake_logger.h
@@ -65,7 +65,8 @@
   Status LogSerializedCustomEvent(uint32_t metric_id,
                                   std::unique_ptr<std::string> serialized_proto) override;
 
-  void RecordLoggerCall(PerProjectLoggerCallsMadeMetricDimensionLoggerMethod method) override {
+  void RecordLoggerCall(
+      PerProjectLoggerCallsMadeMigratedMetricDimensionLoggerMethod method) override {
     if (!internal_logging_paused_) {
       internal_logger_calls_[method]++;
     }
@@ -82,7 +83,8 @@
   uint32_t call_count() const { return call_count_; }
   Event last_event_logged() const { return last_event_logged_; }
   Event nth_event_logged(int64_t n) const { return events_logged_[n]; }
-  std::map<PerProjectLoggerCallsMadeMetricDimensionLoggerMethod, uint32_t> internal_logger_calls() {
+  std::map<PerProjectLoggerCallsMadeMigratedMetricDimensionLoggerMethod, uint32_t>
+  internal_logger_calls() {
     return internal_logger_calls_;
   }
 
@@ -90,7 +92,8 @@
   Event last_event_logged_;
   std::vector<Event> events_logged_;
   uint32_t call_count_ = 0;
-  std::map<PerProjectLoggerCallsMadeMetricDimensionLoggerMethod, uint32_t> internal_logger_calls_;
+  std::map<PerProjectLoggerCallsMadeMigratedMetricDimensionLoggerMethod, uint32_t>
+      internal_logger_calls_;
   bool internal_logging_paused_ = false;
 };
 
diff --git a/src/logger/internal_metrics.cc b/src/logger/internal_metrics.cc
index 254e3de..008a34c 100644
--- a/src/logger/internal_metrics.cc
+++ b/src/logger/internal_metrics.cc
@@ -4,14 +4,59 @@
 
 #include "src/logger/internal_metrics.h"
 
+#include <cstdint>
 #include <memory>
 #include <sstream>
 #include <utility>
 
 #include "src/logger/internal_metrics_config.cb.h"
 #include "src/logging.h"
+#include "src/public/lib/registry_identifiers.h"
 
 namespace cobalt::logger {
+namespace {
+const std::map<std::string, uint32_t> project_map = {
+    {"2147483647/205836624", 1},
+    {"1/929352809", 2},
+    {"1/657579885", 3},
+    {"1/7", 4},
+    {"1/2322225253", 5},
+    {"1/4", 6},
+    {"1/5", 7},
+    {"1/3708719327", 8},
+    {"1/4228153068", 9},
+    {"1/2", 10},
+    {"1/2820332838", 11},
+    {"1/1334068210", 12},
+    {"1/3676913920", 13},
+    {"1/285903809", 14},
+    {"1/3142410971", 15},
+    {"1/3509424520", 16},
+    {"1/2165403525", 17},
+    {"1/1", 18},
+    {"1/3", 19},
+    {"1/2550112954", 20},
+    {"1/4247972873", 21},
+    {"1/6", 22},
+    {"1/8", 23},
+    {"1/9", 24},
+    {"1/10", 25},
+    {"1/11", 26},
+    {"1/12", 27},
+    {"1/13", 28},
+    {"1/14", 29},
+    {"1/15", 30},
+    {"1/16", 31},
+};
+
+uint32_t GetProjectEventCode(const std::string& project_identifier) {
+  auto event_code = project_map.find(project_identifier);
+  if (event_code != project_map.end()) {
+    return event_code->second;
+  }
+  return 0;
+}
+}  // namespace
 
 std::unique_ptr<InternalMetrics> InternalMetrics::NewWithLogger(LoggerInterface* logger,
                                                                 DiagnosticsInterface* diagnostics) {
@@ -26,22 +71,22 @@
   CHECK(logger_);
 }
 
-void InternalMetricsImpl::LoggerCalled(PerProjectLoggerCallsMadeMetricDimensionLoggerMethod method,
-                                       const Project& project) {
+void InternalMetricsImpl::LoggerCalled(
+    PerProjectLoggerCallsMadeMigratedMetricDimensionLoggerMethod method, const Project& project) {
   fields_.lock()->queued_lambdas.emplace_back([this, method, project] {
-    auto status = logger_->LogEventCount(kLoggerCallsMadeMetricId, {method}, "", 0, 1);
+    auto status = logger_->LogOccurrence(kLoggerCallsMadeMigratedMetricId, 1, {method});
 
     if (!status.ok()) {
-      VLOG(1) << "InternalMetricsImpl::LoggerCalled: LogEventCount() returned status=" << status;
+      VLOG(1) << "InternalMetricsImpl::LoggerCalled: LogOccurrence() returned status=" << status;
     }
 
     std::ostringstream component;
-    component << project.customer_name() << '/' << project.project_name();
-    status =
-        logger_->LogEventCount(kPerProjectLoggerCallsMadeMetricId, {method}, component.str(), 0, 1);
+    component << project.customer_id() << '/' << project.project_id();
+    status = logger_->LogOccurrence(kPerProjectLoggerCallsMadeMigratedMetricId, 1,
+                                    {GetProjectEventCode(component.str()), method});
 
     if (!status.ok()) {
-      VLOG(1) << "InternalMetricsImpl::LoggerCalled: LogEventCount() returned status=" << status;
+      VLOG(1) << "InternalMetricsImpl::LoggerCalled: LogOccurrence() returned status=" << status;
     }
 
     if (diagnostics_ != nullptr) {
@@ -50,19 +95,11 @@
   });
 }
 
-void InternalMetricsImpl::BytesUploaded(PerDeviceBytesUploadedMetricDimensionStatus upload_status,
+void InternalMetricsImpl::BytesUploaded(BytesUploadedMetricDimensionStatus upload_status,
                                         size_t byte_count) {
   fields_.lock()->queued_lambdas.emplace_back([this, upload_status, byte_count] {
-    Status status = logger_->LogEventCount(kPerDeviceBytesUploadedMetricId, {upload_status}, "", 0,
-                                           static_cast<uint32_t>(byte_count));
-
-    if (!status.ok()) {
-      VLOG(1) << "InternalMetricsImpl::BytesUploaded: LogEventCount() returned "
-              << "status=" << status;
-    }
-
-    status = logger_->LogOccurrence(kBytesUploadedMetricId, static_cast<uint64_t>(byte_count),
-                                    {upload_status});
+    Status status = logger_->LogOccurrence(kBytesUploadedMetricId,
+                                           static_cast<uint64_t>(byte_count), {upload_status});
 
     if (!status.ok()) {
       VLOG(1) << "InternalMetricsImpl::BytesUploaded: LogOccurrence() returned "
@@ -71,94 +108,88 @@
   });
 }
 
-void InternalMetricsImpl::BytesUploaded(PerProjectBytesUploadedMetricDimensionStatus upload_status,
-                                        size_t byte_count, uint32_t customer_id,
-                                        uint32_t project_id) {
+void InternalMetricsImpl::BytesUploaded(
+    PerProjectBytesUploadedMigratedMetricDimensionStatus upload_status, size_t byte_count,
+    const lib::ProjectIdentifier& project_identifier) {
   fields_.lock()->queued_lambdas.emplace_back(
-      [this, upload_status, byte_count, customer_id, project_id] {
+      [this, upload_status, byte_count, project_identifier] {
         std::ostringstream component;
-        component << customer_id << '/' << project_id;
+        component << project_identifier.customer_id() << '/' << project_identifier.project_id();
 
-        auto status = logger_->LogEventCount(kPerProjectBytesUploadedMetricId, {upload_status},
-                                             component.str(), 0, static_cast<int64_t>(byte_count));
+        auto status = logger_->LogInteger(kPerProjectBytesUploadedMigratedMetricId,
+                                          static_cast<int64_t>(byte_count),
+                                          {GetProjectEventCode(component.str()), upload_status});
 
         if (!status.ok()) {
-          VLOG(1) << "InternalMetricsImpl::BytesUploaded: LogEventCount() returned "
+          VLOG(1) << "InternalMetricsImpl::BytesUploaded: LogInteger() returned "
                   << "status=" << status;
         }
       });
 }
 
-void InternalMetricsImpl::BytesStored(PerProjectBytesStoredMetricDimensionStatus upload_status,
-                                      size_t byte_count, uint32_t customer_id,
-                                      uint32_t project_id) {
-  fields_.lock()->queued_lambdas.emplace_back([this, upload_status, byte_count, customer_id,
-                                               project_id] {
-    std::ostringstream component;
-    component << customer_id << '/' << project_id;
+void InternalMetricsImpl::BytesStored(
+    PerProjectBytesStoredMigratedMetricDimensionStatus upload_status, size_t byte_count,
+    const lib::ProjectIdentifier& project_identifier) {
+  fields_.lock()->queued_lambdas.emplace_back(
+      [this, upload_status, byte_count, project_identifier] {
+        std::ostringstream component;
+        component << project_identifier.customer_id() << '/' << project_identifier.project_id();
 
-    auto status = logger_->LogMemoryUsage(kPerProjectBytesStoredMetricId, {upload_status},
-                                          component.str(), static_cast<int64_t>(byte_count));
+        auto status = logger_->LogInteger(kPerProjectBytesStoredMigratedMetricId,
+                                          static_cast<int64_t>(byte_count),
+                                          {GetProjectEventCode(component.str()), upload_status});
 
-    if (!status.ok()) {
-      VLOG(1) << "InternalMetricsImpl::BytesStored: LogMemoryUsage() returned status=" << status;
-    }
-  });
+        if (!status.ok()) {
+          VLOG(1) << "InternalMetricsImpl::BytesStored: LogInteger() returned status=" << status;
+        }
+      });
 }
 
 void InternalMetricsImpl::IdleObservationUpload(
-    IdleObservationUploadMetricDimensionDeviceState state) {
+    IdleObservationUploadMigratedMetricDimensionDeviceState state) {
   fields_.lock()->queued_lambdas.emplace_back([this, state] {
-    auto status = logger_->LogEventCount(kIdleObservationUploadMetricId, {state}, "", 0, 1);
+    auto status = logger_->LogOccurrence(kIdleObservationUploadMigratedMetricId, 1, {state});
     if (!status.ok()) {
-      VLOG(1) << "InternalMetricsImpl::IdleObservationUpload: LogEventCount() returned status="
+      VLOG(1) << "InternalMetricsImpl::IdleObservationUpload: LogOccurrence() returned status="
               << status;
     }
   });
 }
 
-void InternalMetricsImpl::InaccurateClockEventsCached(int64_t event_count, uint32_t customer_id,
-                                                      uint32_t project_id) {
-  fields_.lock()->queued_lambdas.emplace_back([this, event_count, customer_id, project_id] {
-    std::ostringstream component;
-    component << customer_id << '/' << project_id;
-
-    auto status = logger_->LogEventCount(kInaccurateClockEventsCachedMetricId, {}, component.str(),
-                                         0, event_count);
+void InternalMetricsImpl::InaccurateClockEventsCached(int64_t event_count) {
+  fields_.lock()->queued_lambdas.emplace_back([this, event_count] {
+    auto status =
+        logger_->LogOccurrence(kInaccurateClockEventsCachedMigratedMetricId, event_count, {});
 
     if (!status.ok()) {
       VLOG(1)
-          << "InternalMetricsImpl::InaccurateClockEventsCached: LogEventCount() returned status="
+          << "InternalMetricsImpl::InaccurateClockEventsCached: LogOccurrence() returned status="
           << status;
     }
   });
 }
 
-void InternalMetricsImpl::InaccurateClockEventsDropped(int64_t event_count, uint32_t customer_id,
-                                                       uint32_t project_id) {
-  fields_.lock()->queued_lambdas.emplace_back([this, event_count, customer_id, project_id] {
-    std::ostringstream component;
-    component << customer_id << '/' << project_id;
-
-    auto status = logger_->LogEventCount(kInaccurateClockEventsDroppedMetricId, {}, component.str(),
-                                         0, event_count);
+void InternalMetricsImpl::InaccurateClockEventsDropped(int64_t event_count) {
+  fields_.lock()->queued_lambdas.emplace_back([this, event_count] {
+    auto status =
+        logger_->LogOccurrence(kInaccurateClockEventsDroppedMigratedMetricId, event_count, {});
 
     if (!status.ok()) {
       VLOG(1)
-          << "InternalMetricsImpl::InaccurateClockEventsDropped: LogEventCount() returned status="
+          << "InternalMetricsImpl::InaccurateClockEventsDropped: LogOccurrence() returned status="
           << status;
     }
   });
 }
 
 void InternalMetricsImpl::SetSoftwareDistributionInfoCalled(
-    SetSoftwareDistributionInfoCalledEventCodes event_codes) {
+    SetSoftwareDistributionInfoCalledMigratedEventCodes event_codes) {
   fields_.lock()->queued_lambdas.emplace_back([this, event_codes] {
-    auto status = logger_->LogEventCount(kSetSoftwareDistributionInfoCalledMetricId,
-                                         event_codes.ToVector(), "", 0, 1);
+    auto status = logger_->LogOccurrence(kSetSoftwareDistributionInfoCalledMigratedMetricId, 1,
+                                         event_codes.ToVector());
 
     if (!status.ok()) {
-      VLOG(1) << "InternalMetricsImpl::SetSoftwareDistributionInfoCalled: LogEventCount() returned "
+      VLOG(1) << "InternalMetricsImpl::SetSoftwareDistributionInfoCalled: LogOccurrence() returned "
                  "status="
               << status;
     }
diff --git a/src/logger/internal_metrics.h b/src/logger/internal_metrics.h
index 4dfda4c..36b9434 100644
--- a/src/logger/internal_metrics.h
+++ b/src/logger/internal_metrics.h
@@ -13,6 +13,7 @@
 #include "src/logger/internal_metrics_config.cb.h"
 #include "src/logger/logger_interface.h"
 #include "src/public/diagnostics_interface.h"
+#include "src/public/lib/registry_identifiers.h"
 #include "src/registry/project.pb.h"
 
 namespace cobalt::logger {
@@ -33,47 +34,47 @@
   static std::unique_ptr<InternalMetrics> NewWithLogger(LoggerInterface* logger,
                                                         DiagnosticsInterface* diagnostics);
 
-  // LoggerCalled (cobalt_internal::metrics::logger_calls_made) and
-  // (cobalt_internal::metrics::per_project_logger_calls_made) are logged for
-  // every call to Logger along with which method was called and the project
-  // that called it.
-  virtual void LoggerCalled(PerProjectLoggerCallsMadeMetricDimensionLoggerMethod method,
+  // LoggerCalled (cobalt_internal::metrics::logger_calls_made_migrated) and
+  // (cobalt_internal::metrics::per_project_logger_calls_made_migrated) are
+  // logged for every call to Logger along with which method was called and
+  // the project that called it.
+  virtual void LoggerCalled(PerProjectLoggerCallsMadeMigratedMetricDimensionLoggerMethod method,
                             const Project& project) = 0;
 
-  // cobalt_internal::metrics::per_device_bytes_uploaded is logged when the
-  // Clearcut Uploader attempts or succeeds to upload observations from the
-  // device.
-  virtual void BytesUploaded(PerDeviceBytesUploadedMetricDimensionStatus upload_status,
+  // cobalt_internal::metrics::bytes_uploaded is logged when the Clearcut
+  // Uploader attempts or succeeds to upload observations from the device.
+  virtual void BytesUploaded(BytesUploadedMetricDimensionStatus upload_status,
                              size_t byte_count) = 0;
 
-  // cobalt_internal::metrics::per_project_bytes_uploaded is logged when the
-  // Shipping Manager attempts or succeeds to store observations on the device.
-  virtual void BytesUploaded(PerProjectBytesUploadedMetricDimensionStatus upload_status,
-                             size_t byte_count, uint32_t customer_id, uint32_t project_id) = 0;
+  // cobalt_internal::metrics::per_project_bytes_uploaded_migrated is logged when
+  // the Shipping Manager attempts or succeeds to store observations on the device.
+  virtual void BytesUploaded(PerProjectBytesUploadedMigratedMetricDimensionStatus upload_status,
+                             size_t byte_count,
+                             const lib::ProjectIdentifier& project_identifier) = 0;
 
-  // cobalt_internal::metrics::per_project_bytes_stored is logged when the
+  // cobalt_internal::metrics::per_project_bytes_stored_migrated is logged when the
   // Observation Store attempts or succeeds to store observations on the device.
-  virtual void BytesStored(PerProjectBytesStoredMetricDimensionStatus upload_status,
-                           size_t byte_count, uint32_t customer_id, uint32_t project_id) = 0;
+  virtual void BytesStored(PerProjectBytesStoredMigratedMetricDimensionStatus upload_status,
+                           size_t byte_count, const lib::ProjectIdentifier& project_identifier) = 0;
 
-  // cobalt_internal::metrics::idle_observation_upload is logged when the
+  // cobalt_internal::metrics::idle_observation_upload_migrated is logged when the
   // Shipping Manager encrypts and uploads observations.
-  virtual void IdleObservationUpload(IdleObservationUploadMetricDimensionDeviceState state) = 0;
+  virtual void IdleObservationUpload(
+      IdleObservationUploadMigratedMetricDimensionDeviceState state) = 0;
 
-  // cobalt_internal::metrics::inaccurate_clock_events_cached is logged when the
-  // UndatedEventManager saves an event while the clock is inaccurate.
-  virtual void InaccurateClockEventsCached(int64_t event_count, uint32_t customer_id,
-                                           uint32_t project_id) = 0;
+  // cobalt_internal::metrics::inaccurate_clock_events_cached_migrated is logged when
+  // the UndatedEventManager saves an event while the clock is inaccurate.
+  virtual void InaccurateClockEventsCached(int64_t event_count) = 0;
 
-  // cobalt_internal::metrics::inaccurate_clock_events_dropped is logged when the
-  // UndatedEventManager drops a saved event while the clock is inaccurate and it runs out of space.
-  virtual void InaccurateClockEventsDropped(int64_t event_count, uint32_t customer_id,
-                                            uint32_t project_id) = 0;
+  // cobalt_internal::metrics::inaccurate_clock_events_dropped_migrated is logged when
+  // the UndatedEventManager drops a saved event while the clock is inaccurate and it
+  // runs out of space.
+  virtual void InaccurateClockEventsDropped(int64_t event_count) = 0;
 
-  // cobalt_internal::metrics::set_software_distribution_info_called is logged
+  // cobalt_internal::metrics::set_software_distribution_info_called_migrated is logged
   // when the SystemData receives SoftwareDistributionInfo.
   virtual void SetSoftwareDistributionInfoCalled(
-      SetSoftwareDistributionInfoCalledEventCodes event_codes) = 0;
+      SetSoftwareDistributionInfoCalledMigratedEventCodes event_codes) = 0;
 
   // Used to mark which class this disk usage is coming from. Can be:
   // - ObservationStore
@@ -82,7 +83,7 @@
   // - ObservationHistory
   using StorageClass = MetricsMetricDimensionStorageClass;
 
-  // cobalt_internal::metrics::storage_usage is used to track how much data is stored per-class on
+  // cobalt_internal::metrics::store_usage is used to track how much data is stored per-class on
   // disk.
   virtual void TrackDiskUsage(StorageClass storage_class, size_t bytes, int64_t max_bytes) = 0;
   void TrackDiskUsage(StorageClass storage_class, size_t bytes) {
@@ -106,32 +107,28 @@
 // no LoggerInterface* was provided.
 class NoOpInternalMetrics : public InternalMetrics {
  public:
-  void LoggerCalled(PerProjectLoggerCallsMadeMetricDimensionLoggerMethod method,
+  void LoggerCalled(PerProjectLoggerCallsMadeMigratedMetricDimensionLoggerMethod method,
                     const Project& project) override {}
 
-  void BytesUploaded(PerDeviceBytesUploadedMetricDimensionStatus upload_status,
-                     size_t byte_count) override {}
+  void BytesUploaded(BytesUploadedMetricDimensionStatus upload_status, size_t byte_count) override {
+  }
 
-  // TODO(fxbug.dev/85571): NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
-  void BytesUploaded(PerProjectBytesUploadedMetricDimensionStatus upload_status, size_t byte_count,
-                     uint32_t customer_id, uint32_t project_id) override {}
+  void BytesUploaded(PerProjectBytesUploadedMigratedMetricDimensionStatus upload_status,
+                     size_t byte_count, const lib::ProjectIdentifier& project_identifier) override {
+  }
 
-  // TODO(fxbug.dev/85571): NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
-  void BytesStored(PerProjectBytesStoredMetricDimensionStatus upload_status, size_t byte_count,
-                   uint32_t customer_id, uint32_t project_id) override {}
+  void BytesStored(PerProjectBytesStoredMigratedMetricDimensionStatus upload_status,
+                   size_t byte_count, const lib::ProjectIdentifier& project_identifier) override {}
 
-  void IdleObservationUpload(IdleObservationUploadMetricDimensionDeviceState state) override {}
+  void IdleObservationUpload(
+      IdleObservationUploadMigratedMetricDimensionDeviceState state) override {}
 
-  // TODO(fxbug.dev/85571): NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
-  void InaccurateClockEventsCached(int64_t event_count, uint32_t customer_id,
-                                   uint32_t project_id) override {}
+  void InaccurateClockEventsCached(int64_t event_count) override {}
 
-  // TODO(fxbug.dev/85571): NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
-  void InaccurateClockEventsDropped(int64_t event_count, uint32_t customer_id,
-                                    uint32_t project_id) override {}
+  void InaccurateClockEventsDropped(int64_t event_count) override {}
 
   void SetSoftwareDistributionInfoCalled(
-      SetSoftwareDistributionInfoCalledEventCodes event_codes) override {}
+      SetSoftwareDistributionInfoCalledMigratedEventCodes event_codes) override {}
 
   // TODO(fxbug.dev/85571): NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
   void TrackDiskUsage(StorageClass storage_class, size_t bytes, int64_t max_bytes) override {}
@@ -150,28 +147,26 @@
  public:
   InternalMetricsImpl(LoggerInterface* logger, DiagnosticsInterface* diagnostics);
 
-  void LoggerCalled(PerProjectLoggerCallsMadeMetricDimensionLoggerMethod method,
+  void LoggerCalled(PerProjectLoggerCallsMadeMigratedMetricDimensionLoggerMethod method,
                     const Project& project) override;
 
-  void BytesUploaded(PerDeviceBytesUploadedMetricDimensionStatus upload_status,
-                     size_t byte_count) override;
+  void BytesUploaded(BytesUploadedMetricDimensionStatus upload_status, size_t byte_count) override;
 
-  void BytesUploaded(PerProjectBytesUploadedMetricDimensionStatus upload_status, size_t byte_count,
-                     uint32_t customer_id, uint32_t project_id) override;
+  void BytesUploaded(PerProjectBytesUploadedMigratedMetricDimensionStatus upload_status,
+                     size_t byte_count, const lib::ProjectIdentifier& project_identifier) override;
 
-  void BytesStored(PerProjectBytesStoredMetricDimensionStatus upload_status, size_t byte_count,
-                   uint32_t customer_id, uint32_t project_id) override;
+  void BytesStored(PerProjectBytesStoredMigratedMetricDimensionStatus upload_status,
+                   size_t byte_count, const lib::ProjectIdentifier& project_identifier) override;
 
-  void IdleObservationUpload(IdleObservationUploadMetricDimensionDeviceState state) override;
+  void IdleObservationUpload(
+      IdleObservationUploadMigratedMetricDimensionDeviceState state) override;
 
-  void InaccurateClockEventsCached(int64_t event_count, uint32_t customer_id,
-                                   uint32_t project_id) override;
+  void InaccurateClockEventsCached(int64_t event_count) override;
 
-  void InaccurateClockEventsDropped(int64_t event_count, uint32_t customer_id,
-                                    uint32_t project_id) override;
+  void InaccurateClockEventsDropped(int64_t event_count) override;
 
   void SetSoftwareDistributionInfoCalled(
-      SetSoftwareDistributionInfoCalledEventCodes event_codes) override;
+      SetSoftwareDistributionInfoCalledMigratedEventCodes event_codes) override;
 
   void TrackDiskUsage(StorageClass storage_class, size_t bytes, int64_t max_bytes) override;
 
@@ -221,56 +216,54 @@
   explicit InternalMetricsPauseWrapper(InternalMetrics* internal_metrics)
       : wrapped_internal_metrics_(internal_metrics) {}
 
-  void LoggerCalled(PerProjectLoggerCallsMadeMetricDimensionLoggerMethod method,
+  void LoggerCalled(PerProjectLoggerCallsMadeMigratedMetricDimensionLoggerMethod method,
                     const Project& project) override {
     if (!paused_) {
       wrapped_internal_metrics_->LoggerCalled(method, project);
     }
   }
 
-  void BytesUploaded(PerDeviceBytesUploadedMetricDimensionStatus upload_status,
-                     size_t byte_count) override {
+  void BytesUploaded(BytesUploadedMetricDimensionStatus upload_status, size_t byte_count) override {
     if (!paused_) {
       wrapped_internal_metrics_->BytesUploaded(upload_status, byte_count);
     }
   }
 
-  void BytesUploaded(PerProjectBytesUploadedMetricDimensionStatus upload_status, size_t byte_count,
-                     uint32_t customer_id, uint32_t project_id) override {
+  void BytesUploaded(PerProjectBytesUploadedMigratedMetricDimensionStatus upload_status,
+                     size_t byte_count, const lib::ProjectIdentifier& project_identifier) override {
     if (!paused_) {
-      wrapped_internal_metrics_->BytesUploaded(upload_status, byte_count, customer_id, project_id);
+      wrapped_internal_metrics_->BytesUploaded(upload_status, byte_count, project_identifier);
     }
   }
 
-  void BytesStored(PerProjectBytesStoredMetricDimensionStatus upload_status, size_t byte_count,
-                   uint32_t customer_id, uint32_t project_id) override {
+  void BytesStored(PerProjectBytesStoredMigratedMetricDimensionStatus upload_status,
+                   size_t byte_count, const lib::ProjectIdentifier& project_identifier) override {
     if (!paused_) {
-      wrapped_internal_metrics_->BytesStored(upload_status, byte_count, customer_id, project_id);
+      wrapped_internal_metrics_->BytesStored(upload_status, byte_count, project_identifier);
     }
   }
 
-  void IdleObservationUpload(IdleObservationUploadMetricDimensionDeviceState state) override {
+  void IdleObservationUpload(
+      IdleObservationUploadMigratedMetricDimensionDeviceState state) override {
     if (!paused_) {
       wrapped_internal_metrics_->IdleObservationUpload(state);
     }
   }
 
-  void InaccurateClockEventsCached(int64_t event_count, uint32_t customer_id,
-                                   uint32_t project_id) override {
+  void InaccurateClockEventsCached(int64_t event_count) override {
     if (!paused_) {
-      wrapped_internal_metrics_->InaccurateClockEventsCached(event_count, customer_id, project_id);
+      wrapped_internal_metrics_->InaccurateClockEventsCached(event_count);
     }
   }
 
-  void InaccurateClockEventsDropped(int64_t event_count, uint32_t customer_id,
-                                    uint32_t project_id) override {
+  void InaccurateClockEventsDropped(int64_t event_count) override {
     if (!paused_) {
-      wrapped_internal_metrics_->InaccurateClockEventsDropped(event_count, customer_id, project_id);
+      wrapped_internal_metrics_->InaccurateClockEventsDropped(event_count);
     }
   }
 
   void SetSoftwareDistributionInfoCalled(
-      SetSoftwareDistributionInfoCalledEventCodes event_codes) override {
+      SetSoftwareDistributionInfoCalledMigratedEventCodes event_codes) override {
     if (!paused_) {
       wrapped_internal_metrics_->SetSoftwareDistributionInfoCalled(event_codes);
     }
diff --git a/src/logger/internal_metrics_test.cc b/src/logger/internal_metrics_test.cc
index e360346..e686b64 100644
--- a/src/logger/internal_metrics_test.cc
+++ b/src/logger/internal_metrics_test.cc
@@ -9,6 +9,7 @@
 #include <gtest/gtest.h>
 
 #include "src/logger/fake_logger.h"
+#include "src/public/lib/registry_identifiers.h"
 
 namespace cobalt::logger {
 
@@ -33,13 +34,14 @@
   testing::FakeLogger logger;
   InternalMetricsImpl metrics(&logger, nullptr);
 
-  metrics.LoggerCalled(PerProjectLoggerCallsMadeMetricDimensionLoggerMethod::LogMemoryUsage,
+  metrics.LoggerCalled(PerProjectLoggerCallsMadeMigratedMetricDimensionLoggerMethod::LogMemoryUsage,
                        GetTestProject());
   metrics.Flush();
 
   ASSERT_EQ(logger.call_count(), 2);
-  ASSERT_TRUE(logger.last_event_logged().has_event_count_event());
-  ASSERT_EQ(logger.last_event_logged().event_count_event().component(), "test/project");
+  ASSERT_TRUE(logger.last_event_logged().has_occurrence_event());
+  ASSERT_EQ(logger.last_event_logged().occurrence_event().count(), 1);
+  ASSERT_EQ(logger.last_event_logged().occurrence_event().event_code(0), 10);
 }
 
 TEST_F(InternalMetricsImplTest, LoggerCalledPauseWorks) {
@@ -49,8 +51,9 @@
 
   metrics.PauseLogging();
   for (int i = 0; i < kMany; i++) {
-    metrics.LoggerCalled(PerProjectLoggerCallsMadeMetricDimensionLoggerMethod::LogMemoryUsage,
-                         GetTestProject());
+    metrics.LoggerCalled(
+        PerProjectLoggerCallsMadeMigratedMetricDimensionLoggerMethod::LogMemoryUsage,
+        GetTestProject());
   }
   metrics.ResumeLogging();
   metrics.Flush();
@@ -63,10 +66,10 @@
   InternalMetricsImpl metrics(&logger, nullptr);
 
   ASSERT_EQ(logger.call_count(), 0);
-  metrics.BytesUploaded(PerDeviceBytesUploadedMetricDimensionStatus::Attempted, kNumBytes);
+  metrics.BytesUploaded(BytesUploadedMetricDimensionStatus::Attempted, kNumBytes);
   metrics.Flush();
 
-  ASSERT_EQ(logger.call_count(), 2);
+  ASSERT_EQ(logger.call_count(), 1);
   ASSERT_TRUE(logger.last_event_logged().has_occurrence_event());
   ASSERT_EQ(logger.last_event_logged().metric_id(), kBytesUploadedMetricId);
   ASSERT_EQ(logger.last_event_logged().occurrence_event().count(), kNumBytes);
@@ -79,7 +82,7 @@
 
   metrics.PauseLogging();
   for (int i = 0; i < kMany; i++) {
-    metrics.BytesUploaded(PerDeviceBytesUploadedMetricDimensionStatus::Attempted, kNumBytes);
+    metrics.BytesUploaded(BytesUploadedMetricDimensionStatus::Attempted, kNumBytes);
   }
   metrics.ResumeLogging();
   metrics.Flush();
@@ -91,13 +94,14 @@
   InternalMetricsImpl metrics(&logger, nullptr);
 
   ASSERT_EQ(logger.call_count(), 0);
-  metrics.BytesUploaded(PerProjectBytesUploadedMetricDimensionStatus::Attempted, kNumBytes,
-                        kTestCustomerId, kTestProjectId);
+  metrics.BytesUploaded(
+      PerProjectBytesUploadedMigratedMetricDimensionStatus::Attempted, kNumBytes,
+      lib::ProjectIdentifier(lib::CustomerIdentifier(kTestCustomerId), kTestProjectId));
   metrics.Flush();
 
   ASSERT_EQ(logger.call_count(), 1);
-  ASSERT_TRUE(logger.last_event_logged().has_event_count_event());
-  ASSERT_EQ(logger.last_event_logged().event_count_event().count(), kNumBytes);
+  ASSERT_TRUE(logger.last_event_logged().has_integer_event());
+  ASSERT_EQ(logger.last_event_logged().integer_event().value(), kNumBytes);
 }
 
 TEST_F(InternalMetricsImplTest, MegaBytesUploadedPauseWorks) {
@@ -107,8 +111,9 @@
 
   metrics.PauseLogging();
   for (int i = 0; i < kMany; i++) {
-    metrics.BytesUploaded(PerProjectBytesUploadedMetricDimensionStatus::Attempted, kNumBytes,
-                          kTestCustomerId, kTestProjectId);
+    metrics.BytesUploaded(
+        PerProjectBytesUploadedMigratedMetricDimensionStatus::Attempted, kNumBytes,
+        lib::ProjectIdentifier(lib::CustomerIdentifier(kTestCustomerId), kTestProjectId));
   }
   metrics.ResumeLogging();
   metrics.Flush();
@@ -120,13 +125,14 @@
   InternalMetricsImpl metrics(&logger, nullptr);
 
   ASSERT_EQ(logger.call_count(), 0);
-  metrics.BytesStored(PerProjectBytesStoredMetricDimensionStatus::Attempted, kNumBytes,
-                      kTestCustomerId, kTestProjectId);
+  metrics.BytesStored(
+      PerProjectBytesStoredMigratedMetricDimensionStatus::Attempted, kNumBytes,
+      lib::ProjectIdentifier(lib::CustomerIdentifier(kTestCustomerId), kTestProjectId));
   metrics.Flush();
 
   ASSERT_EQ(logger.call_count(), 1);
-  ASSERT_TRUE(logger.last_event_logged().has_memory_usage_event());
-  ASSERT_EQ(logger.last_event_logged().memory_usage_event().bytes(), kNumBytes);
+  ASSERT_TRUE(logger.last_event_logged().has_integer_event());
+  ASSERT_EQ(logger.last_event_logged().integer_event().value(), kNumBytes);
 }
 
 TEST_F(InternalMetricsImplTest, BytesStoredPauseWorks) {
@@ -136,8 +142,9 @@
 
   metrics.PauseLogging();
   for (int i = 0; i < kMany; i++) {
-    metrics.BytesStored(PerProjectBytesStoredMetricDimensionStatus::Attempted, kNumBytes,
-                        kTestCustomerId, kTestProjectId);
+    metrics.BytesStored(
+        PerProjectBytesStoredMigratedMetricDimensionStatus::Attempted, kNumBytes,
+        lib::ProjectIdentifier(lib::CustomerIdentifier(kTestCustomerId), kTestProjectId));
   }
   metrics.ResumeLogging();
   metrics.Flush();
@@ -149,12 +156,12 @@
   InternalMetricsImpl metrics(&logger, nullptr);
 
   ASSERT_EQ(logger.call_count(), 0);
-  metrics.IdleObservationUpload(IdleObservationUploadMetricDimensionDeviceState_Active);
+  metrics.IdleObservationUpload(IdleObservationUploadMigratedMetricDimensionDeviceState_Active);
   metrics.Flush();
 
   ASSERT_EQ(logger.call_count(), 1);
-  ASSERT_TRUE(logger.last_event_logged().has_event_count_event());
-  ASSERT_EQ(logger.last_event_logged().event_count_event().count(), 1);
+  ASSERT_TRUE(logger.last_event_logged().has_occurrence_event());
+  ASSERT_EQ(logger.last_event_logged().occurrence_event().count(), 1);
 }
 
 TEST_F(InternalMetricsImplTest, IdleObservationUploadPauseWorks) {
@@ -164,7 +171,7 @@
 
   metrics.PauseLogging();
   for (int i = 0; i < kMany; i++) {
-    metrics.IdleObservationUpload(IdleObservationUploadMetricDimensionDeviceState_Active);
+    metrics.IdleObservationUpload(IdleObservationUploadMigratedMetricDimensionDeviceState_Active);
   }
   metrics.ResumeLogging();
   metrics.Flush();
@@ -177,12 +184,12 @@
 
   ASSERT_EQ(logger.call_count(), 0);
   metrics.SetSoftwareDistributionInfoCalled(
-      {SetSoftwareDistributionInfoCalledMetricDimensionNewRealm::Valid});
+      {SetSoftwareDistributionInfoCalledMigratedMetricDimensionNewRealm::Valid});
   metrics.Flush();
 
   ASSERT_EQ(logger.call_count(), 1);
-  ASSERT_TRUE(logger.last_event_logged().has_event_count_event());
-  ASSERT_EQ(logger.last_event_logged().event_count_event().count(), 1);
+  ASSERT_TRUE(logger.last_event_logged().has_occurrence_event());
+  ASSERT_EQ(logger.last_event_logged().occurrence_event().count(), 1);
 }
 
 TEST_F(InternalMetricsImplTest, SetSoftwareDistributionInfoCalledPauseWorks) {
@@ -193,7 +200,7 @@
   metrics.PauseLogging();
   for (int i = 0; i < kMany; i++) {
     metrics.SetSoftwareDistributionInfoCalled(
-        {SetSoftwareDistributionInfoCalledMetricDimensionNewRealm::Valid});
+        {SetSoftwareDistributionInfoCalledMigratedMetricDimensionNewRealm::Valid});
   }
   metrics.ResumeLogging();
   metrics.Flush();
diff --git a/src/logger/logger.cc b/src/logger/logger.cc
index 1bbd25d..5f00e92 100644
--- a/src/logger/logger.cc
+++ b/src/logger/logger.cc
@@ -19,7 +19,7 @@
 
 using local_aggregation::EventAggregator;
 
-using LoggerMethod = PerProjectLoggerCallsMadeMetricDimensionLoggerMethod;
+using LoggerMethod = PerProjectLoggerCallsMadeMigratedMetricDimensionLoggerMethod;
 
 namespace {
 template <class EventType>
diff --git a/src/logger/logger.h b/src/logger/logger.h
index 3609342..058fc21 100644
--- a/src/logger/logger.h
+++ b/src/logger/logger.h
@@ -173,11 +173,12 @@
   Status LogSerializedCustomEvent(uint32_t metric_id,
                                   std::unique_ptr<std::string> serialized_proto) override;
 
-  // LoggerCalled (cobalt_internal::metrics::logger_calls_made) and
-  // (cobalt_internal::metrics::per_project_logger_calls_made) are logged for
-  // every call to Logger along with which method was called and the project
+  // LoggerCalled (cobalt_internal::metrics::logger_calls_made_migrated) and
+  // (cobalt_internal::metrics::per_project_logger_calls_made_migrated) are logged
+  // for every call to Logger along with which method was called and the project
   // that called it.
-  void RecordLoggerCall(PerProjectLoggerCallsMadeMetricDimensionLoggerMethod method) override {
+  void RecordLoggerCall(
+      PerProjectLoggerCallsMadeMigratedMetricDimensionLoggerMethod method) override {
     internal_metrics_.LoggerCalled(method, project_context_->project());
   }
 
diff --git a/src/logger/logger_interface.h b/src/logger/logger_interface.h
index 461a9c4..7e45967 100644
--- a/src/logger/logger_interface.h
+++ b/src/logger/logger_interface.h
@@ -227,11 +227,12 @@
   virtual Status LogSerializedCustomEvent(uint32_t metric_id,
                                           std::unique_ptr<std::string> serialized_proto) = 0;
 
-  // LoggerCalled (cobalt_internal::metrics::logger_calls_made) and
-  // (cobalt_internal::metrics::per_project_logger_calls_made) are logged for
-  // every call to Logger along with which method was called and the project
+  // LoggerCalled (cobalt_internal::metrics::logger_calls_made_migrated) and
+  // (cobalt_internal::metrics::per_project_logger_calls_made_migrated) are logged
+  // for every call to Logger along with which method was called and the project
   // that called it.
-  virtual void RecordLoggerCall(PerProjectLoggerCallsMadeMetricDimensionLoggerMethod method) = 0;
+  virtual void RecordLoggerCall(
+      PerProjectLoggerCallsMadeMigratedMetricDimensionLoggerMethod method) = 0;
 
   // Pauses Cobalt's internal metrics collection.
   virtual void PauseInternalLogging() = 0;
diff --git a/src/logger/undated_event_manager.cc b/src/logger/undated_event_manager.cc
index 587a61b..e52c33d 100644
--- a/src/logger/undated_event_manager.cc
+++ b/src/logger/undated_event_manager.cc
@@ -99,15 +99,13 @@
 
   // Record that we saved records due to clock inaccuracy.
   for (auto cached_events : lock->num_events_cached_) {
-    auto id = cached_events.first;
-    internal_metrics->InaccurateClockEventsCached(cached_events.second, id.first, id.second);
+    internal_metrics->InaccurateClockEventsCached(cached_events.second);
   }
   lock->num_events_cached_.clear();
 
   // Record that we dropped events due to memory constraints.
   for (auto dropped_events : lock->num_events_dropped_) {
-    auto id = dropped_events.first;
-    internal_metrics->InaccurateClockEventsDropped(dropped_events.second, id.first, id.second);
+    internal_metrics->InaccurateClockEventsDropped(dropped_events.second);
   }
   lock->num_events_dropped_.clear();
 
diff --git a/src/logger/undated_event_manager_test.cc b/src/logger/undated_event_manager_test.cc
index a9347f8..bddc9fd 100644
--- a/src/logger/undated_event_manager_test.cc
+++ b/src/logger/undated_event_manager_test.cc
@@ -169,8 +169,8 @@
   // One internal metric call for the number of cached events.
   internal_metrics_->Flush();
   EXPECT_EQ(1, internal_logger_->call_count());
-  EXPECT_EQ(kInaccurateClockEventsCachedMetricId,
-            internal_logger_->last_event_logged().metric_id());
+  EXPECT_EQ(internal_logger_->last_event_logged().metric_id(),
+            kInaccurateClockEventsCachedMigratedMetricId);
 }
 
 TEST_F(UndatedEventManagerTest, OneImmediatelyFlushedEvent) {
@@ -202,8 +202,8 @@
   // One internal metric call for the number of cached events.
   internal_metrics_->Flush();
   EXPECT_EQ(1, internal_logger_->call_count());
-  EXPECT_EQ(kInaccurateClockEventsCachedMetricId,
-            internal_logger_->last_event_logged().metric_id());
+  EXPECT_EQ(internal_logger_->last_event_logged().metric_id(),
+            kInaccurateClockEventsCachedMigratedMetricId);
 }
 
 TEST_F(UndatedEventManagerTest, OneDayDelayInSystemClockAccuracy) {
@@ -237,8 +237,8 @@
   // One internal metric call for the number of cached events.
   internal_metrics_->Flush();
   EXPECT_EQ(1, internal_logger_->call_count());
-  EXPECT_EQ(kInaccurateClockEventsCachedMetricId,
-            internal_logger_->last_event_logged().metric_id());
+  EXPECT_EQ(internal_logger_->last_event_logged().metric_id(),
+            kInaccurateClockEventsCachedMigratedMetricId);
 }
 
 TEST_F(UndatedEventManagerTest, TooManyEventsToStore) {
@@ -306,8 +306,8 @@
   internal_metrics_->Flush();
   // Two internal metric calls for the number of cached and dropped events.
   EXPECT_EQ(2, internal_logger_->call_count());
-  EXPECT_EQ(kInaccurateClockEventsDroppedMetricId,
-            internal_logger_->last_event_logged().metric_id());
+  EXPECT_EQ(internal_logger_->last_event_logged().metric_id(),
+            kInaccurateClockEventsDroppedMigratedMetricId);
 }
 
 TEST_F(UndatedEventManagerTest, SaveAfterFlush) {
diff --git a/src/observation_store/file_observation_store.cc b/src/observation_store/file_observation_store.cc
index 4404497..98bf04b 100644
--- a/src/observation_store/file_observation_store.cc
+++ b/src/observation_store/file_observation_store.cc
@@ -87,8 +87,10 @@
   auto fields = protected_fields_.lock();
 
   size_t obs_size = observation->ByteSizeLong();
-  internal_metrics_->BytesStored(logger::PerProjectBytesStoredMetricDimensionStatus::Attempted,
-                                 obs_size, metadata->customer_id(), metadata->project_id());
+  internal_metrics_->BytesStored(
+      logger::PerProjectBytesStoredMigratedMetricDimensionStatus::Attempted, obs_size,
+      lib::ProjectIdentifier(lib::CustomerIdentifier(metadata->customer_id()),
+                             metadata->project_id()));
 
   google::protobuf::io::ZeroCopyOutputStream *active_file = GetActiveFile(&fields);
   if (active_file == nullptr) {
@@ -175,8 +177,10 @@
                                           static_cast<int64_t>(max_bytes_total_));
   }
   num_obs_per_report_[lib::ReportIdentifier(*metadata)]++;
-  internal_metrics_->BytesStored(logger::PerProjectBytesStoredMetricDimensionStatus::Succeeded,
-                                 obs_size, metadata->customer_id(), metadata->project_id());
+  internal_metrics_->BytesStored(
+      logger::PerProjectBytesStoredMigratedMetricDimensionStatus::Succeeded, obs_size,
+      lib::ProjectIdentifier(lib::CustomerIdentifier(metadata->customer_id()),
+                             metadata->project_id()));
   // Cannot cause a loop, since TrackDiskUsage is handled asynchronously.
   internal_metrics_->TrackDiskUsage(logger::InternalMetrics::StorageClass::ObservationStore,
                                     static_cast<int64_t>(estimated_new_byte_count),
diff --git a/src/observation_store/memory_observation_store.cc b/src/observation_store/memory_observation_store.cc
index 6ff2cbb..7801652 100644
--- a/src/observation_store/memory_observation_store.cc
+++ b/src/observation_store/memory_observation_store.cc
@@ -37,8 +37,10 @@
 
   std::unique_lock<std::mutex> lock(envelope_mutex_);
 
-  internal_metrics_->BytesStored(logger::PerProjectBytesStoredMetricDimensionStatus::Attempted,
-                                 SizeLocked(), metadata->customer_id(), metadata->project_id());
+  internal_metrics_->BytesStored(
+      logger::PerProjectBytesStoredMigratedMetricDimensionStatus::Attempted, SizeLocked(),
+      lib::ProjectIdentifier(lib::CustomerIdentifier(metadata->customer_id()),
+                             metadata->project_id()));
 
   if (SizeLocked() > max_bytes_total_) {
     return Status(StatusCode::RESOURCE_EXHAUSTED,
@@ -65,8 +67,9 @@
   Status status = current_envelope_->StoreObservation(std::move(observation), std::move(metadata));
   if (status.ok()) {
     num_obs_per_report_[report_id]++;
-    internal_metrics_->BytesStored(logger::PerProjectBytesStoredMetricDimensionStatus::Succeeded,
-                                   SizeLocked(), customer_id, project_id);
+    internal_metrics_->BytesStored(
+        logger::PerProjectBytesStoredMigratedMetricDimensionStatus::Succeeded, SizeLocked(),
+        lib::ProjectIdentifier(lib::CustomerIdentifier(customer_id), project_id));
   }
   return status;
 }
diff --git a/src/public/diagnostics_interface.h b/src/public/diagnostics_interface.h
index 4fb4fb9..3f9a23d 100644
--- a/src/public/diagnostics_interface.h
+++ b/src/public/diagnostics_interface.h
@@ -47,7 +47,7 @@
 
   // Logged for every call to Logger along with which method was called and the project
   // that called it.
-  virtual void LoggerCalled(int perProjectLoggerCallsMadeMetricDimensionLoggerMethod,
+  virtual void LoggerCalled(int PerProjectLoggerCallsMadeMigratedMetricDimensionLoggerMethod,
                             const std::string& project) = 0;
 
   // Used to track how much data is stored per-class on disk.
diff --git a/src/system_data/system_data.cc b/src/system_data/system_data.cc
index 30dce80..11963d5 100644
--- a/src/system_data/system_data.cc
+++ b/src/system_data/system_data.cc
@@ -129,8 +129,8 @@
 }
 
 void SystemData::SetSoftwareDistributionInfo(SoftwareDistributionInfo info) {
-  using EventCode = logger::SetSoftwareDistributionInfoCalledMetricDimensionPreviousChannel;
-  logger::SetSoftwareDistributionInfoCalledEventCodes event_codes;
+  using EventCode = logger::SetSoftwareDistributionInfoCalledMigratedMetricDimensionPreviousChannel;
+  logger::SetSoftwareDistributionInfoCalledMigratedEventCodes event_codes;
 
   if (system_profile_.channel() == "<unset>") {
     event_codes.previous_channel = EventCode::Unset;
diff --git a/src/uploader/BUILD.gn b/src/uploader/BUILD.gn
index b6fe3fb..7549fbb 100644
--- a/src/uploader/BUILD.gn
+++ b/src/uploader/BUILD.gn
@@ -19,6 +19,7 @@
     "$cobalt_root/src/public:activity_listener_interface",
     "$cobalt_root/src/public:cobalt_config",
     "$cobalt_root/src/public:diagnostics_interface",
+    "$cobalt_root/src/public/lib:registry_identifiers",
     "$cobalt_root/src/system_data",
     "$cobalt_root/src/system_data:configuration_data",
   ]
diff --git a/src/uploader/shipping_manager.cc b/src/uploader/shipping_manager.cc
index 8c91fa5..1f99e7d 100644
--- a/src/uploader/shipping_manager.cc
+++ b/src/uploader/shipping_manager.cc
@@ -12,6 +12,7 @@
 #include "src/logger/logger_interface.h"
 #include "src/logging.h"
 #include "src/pb/clearcut_extensions.pb.h"
+#include "src/public/lib/registry_identifiers.h"
 #include "third_party/protobuf/src/google/protobuf/util/delimited_message_util.h"
 
 namespace cobalt::uploader {
@@ -294,17 +295,17 @@
     return;
   }
 
-  auto state = logger::IdleObservationUploadMetricDimensionDeviceState::Unreported;
+  auto state = logger::IdleObservationUploadMigratedMetricDimensionDeviceState::Unreported;
   if (activity_listener_ != nullptr) {
     switch (activity_listener_->state()) {
       case ActivityState::ACTIVE:
-        state = logger::IdleObservationUploadMetricDimensionDeviceState::Active;
+        state = logger::IdleObservationUploadMigratedMetricDimensionDeviceState::Active;
         break;
       case ActivityState::UNKNOWN:
-        state = logger::IdleObservationUploadMetricDimensionDeviceState::Unknown;
+        state = logger::IdleObservationUploadMigratedMetricDimensionDeviceState::Unknown;
         break;
       case ActivityState::IDLE:
-        state = logger::IdleObservationUploadMetricDimensionDeviceState::Idle;
+        state = logger::IdleObservationUploadMigratedMetricDimensionDeviceState::Idle;
         break;
     }
   }
@@ -411,8 +412,10 @@
   for (const auto& observation_batch : envelope.batch()) {
     const auto& metadata = observation_batch.meta_data();
     internal_metrics_->BytesUploaded(
-        logger::PerProjectBytesUploadedMetricDimensionStatus::Attempted,
-        observation_batch.ByteSizeLong(), metadata.customer_id(), metadata.project_id());
+        logger::PerProjectBytesUploadedMigratedMetricDimensionStatus::Attempted,
+        observation_batch.ByteSizeLong(),
+        lib::ProjectIdentifier(lib::CustomerIdentifier(metadata.customer_id()),
+                               metadata.project_id()));
   }
 
   VLOG(5) << name() << " worker: Sending Envelope of size " << envelope_size
@@ -441,8 +444,10 @@
     for (const auto& observation_batch : envelope.batch()) {
       const auto& metadata = observation_batch.meta_data();
       internal_metrics_->BytesUploaded(
-          logger::PerProjectBytesUploadedMetricDimensionStatus::Succeeded,
-          observation_batch.GetCachedSize(), metadata.customer_id(), metadata.project_id());
+          logger::PerProjectBytesUploadedMigratedMetricDimensionStatus::Succeeded,
+          observation_batch.GetCachedSize(),
+          lib::ProjectIdentifier(lib::CustomerIdentifier(metadata.customer_id()),
+                                 metadata.project_id()));
     }
   }
   return status;
diff --git a/src/uploader/shipping_manager_test.cc b/src/uploader/shipping_manager_test.cc
index 20692d2..f5ac7fd 100644
--- a/src/uploader/shipping_manager_test.cc
+++ b/src/uploader/shipping_manager_test.cc
@@ -28,7 +28,7 @@
 
 using cobalt::clearcut_extensions::LogEventExtension;
 using lib::statusor::StatusOr;
-using logger::PerProjectBytesUploadedMetricDimensionStatus::Succeeded;
+using logger::PerProjectBytesUploadedMigratedMetricDimensionStatus::Succeeded;
 using logger::testing::FakeLogger;
 using observation_store::MemoryObservationStore;
 using util::EncryptedMessageMaker;
@@ -291,16 +291,15 @@
 
   metrics->Flush();
   // Attempt and Succeed in the Shipping Manager for a project (2), Attempt and Succeed in Clearcut
-  // Uploader with both 1.0 and 1.1 metrics (4), and a IdleObservationUpload when the envelopes are
-  // sent (1).
-  EXPECT_EQ(7, logger.call_count());
+  // Uploader with 1.1 metrics (2), and a IdleObservationUpload when the envelopes are sent (1).
+  EXPECT_EQ(5, logger.call_count());
 
   auto event = logger.last_event_logged();  // The last Succeed for an Observation Batch.
-  EXPECT_TRUE(event.has_event_count_event());
-  EXPECT_EQ(1, event.event_count_event().event_code_size());
-  EXPECT_EQ(Succeeded, event.event_count_event().event_code(0));
-  EXPECT_EQ(absl::StrCat(kCustomerId, "/", kProjectId), event.event_count_event().component());
-  EXPECT_LE(40, event.event_count_event().count());  // This is an estimate.
+  EXPECT_TRUE(event.has_integer_event());
+  EXPECT_EQ(event.integer_event().event_code_size(), 2);
+  EXPECT_EQ(event.integer_event().event_code(0), 0);
+  EXPECT_EQ(event.integer_event().event_code(1), Succeeded);
+  EXPECT_GE(event.integer_event().value(), 40);  // This is an estimate.
 }
 
 // We add two Observations, confirm that they are not immediately sent,
@@ -353,16 +352,16 @@
 
   metrics->Flush();
   // Attempt and Succeed in the Shipping Manager (2), Attempt and Succeed in Clearcut Uploader for
-  // the envelope with both 1.0 and 1.1 metrics (4), and an IdleObservationUpload when the envelopes
-  // are sent (1).
-  EXPECT_EQ(7, logger.call_count());
+  // the envelope with 1.1 metrics (2), and an IdleObservationUpload when the envelopes are
+  // sent (1).
+  EXPECT_EQ(5, logger.call_count());
 
   auto event = logger.last_event_logged();  // The last Succeed for an Observation Batch.
-  EXPECT_TRUE(event.has_event_count_event());
-  EXPECT_EQ(1, event.event_count_event().event_code_size());
-  EXPECT_EQ(Succeeded, event.event_count_event().event_code(0));
-  EXPECT_EQ(absl::StrCat(kCustomerId, "/", kProjectId), event.event_count_event().component());
-  EXPECT_LE(2 * 40, event.event_count_event().count());  // This is an estimate.
+  EXPECT_TRUE(event.has_integer_event());
+  EXPECT_EQ(event.integer_event().event_code_size(), 2);
+  EXPECT_EQ(event.integer_event().event_code(0), 0);
+  EXPECT_EQ(event.integer_event().event_code(1), Succeeded);
+  EXPECT_GE(event.integer_event().value(), 2 * 40);  // This is an estimate.
 }
 
 // Tries to add an Observation that is too big. Tests that kObservationTooBig