diff --git a/api/transport/network_types.h b/api/transport/network_types.h
index 6caa7a1..e26561a 100644
--- a/api/transport/network_types.h
+++ b/api/transport/network_types.h
@@ -176,6 +176,7 @@
   DataRate target_data_rate = DataRate::Zero();
   TimeDelta target_duration = TimeDelta::Zero();
   int32_t target_probe_count = 0;
+  int32_t id = 0;
 };
 
 struct TargetTransferRate {
diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc
index 31e1334..60f3c2d 100644
--- a/call/rtp_transport_controller_send.cc
+++ b/call/rtp_transport_controller_send.cc
@@ -541,7 +541,7 @@
   }
   for (const auto& probe : update.probe_cluster_configs) {
     int64_t bitrate_bps = probe.target_data_rate.bps();
-    pacer_.CreateProbeCluster(bitrate_bps);
+    pacer_.CreateProbeCluster(bitrate_bps, probe.id);
   }
   if (update.target_rate) {
     control_handler_->SetTargetRate(*update.target_rate);
diff --git a/modules/congestion_controller/goog_cc/BUILD.gn b/modules/congestion_controller/goog_cc/BUILD.gn
index cb09ff5..c6ef838 100644
--- a/modules/congestion_controller/goog_cc/BUILD.gn
+++ b/modules/congestion_controller/goog_cc/BUILD.gn
@@ -170,12 +170,14 @@
     "../../../api/units:data_rate",
     "../../../api/units:time_delta",
     "../../../api/units:timestamp",
+    "../../../logging:rtc_event_bwe",
     "../../../logging:rtc_event_log_api",
     "../../../logging:rtc_event_pacing",
     "../../../rtc_base:checks",
     "../../../rtc_base:rtc_base_approved",
     "../../../rtc_base/system:unused",
     "../../../system_wrappers:metrics",
+    "//third_party/abseil-cpp/absl/memory:memory",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
 }
diff --git a/modules/congestion_controller/goog_cc/goog_cc_network_control.cc b/modules/congestion_controller/goog_cc/goog_cc_network_control.cc
index 1ef4a7c..af8594d 100644
--- a/modules/congestion_controller/goog_cc/goog_cc_network_control.cc
+++ b/modules/congestion_controller/goog_cc/goog_cc_network_control.cc
@@ -104,7 +104,7 @@
               .find("Enabled") == 0),
       rate_control_settings_(
           RateControlSettings::ParseFromKeyValueConfig(key_value_config_)),
-      probe_controller_(new ProbeController(key_value_config_)),
+      probe_controller_(new ProbeController(key_value_config_, event_log)),
       congestion_window_pushback_controller_(
           rate_control_settings_.UseCongestionWindowPushback()
               ? absl::make_unique<CongestionWindowPushbackController>(
diff --git a/modules/congestion_controller/goog_cc/probe_controller.cc b/modules/congestion_controller/goog_cc/probe_controller.cc
index fa7a9eb..392fddd 100644
--- a/modules/congestion_controller/goog_cc/probe_controller.cc
+++ b/modules/congestion_controller/goog_cc/probe_controller.cc
@@ -13,10 +13,12 @@
 #include <algorithm>
 #include <initializer_list>
 #include <string>
+#include "absl/memory/memory.h"
 
 #include "api/units/data_rate.h"
 #include "api/units/time_delta.h"
 #include "api/units/timestamp.h"
+#include "logging/rtc_event_log/events/rtc_event_probe_cluster_created.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
@@ -80,16 +82,32 @@
 // Never probe higher than configured by OnMaxTotalAllocatedBitrate().
 constexpr char kCappedProbingFieldTrialName[] = "WebRTC-BweCappedProbing";
 
+void MaybeLogProbeClusterCreated(RtcEventLog* event_log,
+                                 const ProbeClusterConfig& probe) {
+  RTC_DCHECK(event_log);
+  if (!event_log) {
+    return;
+  }
+
+  size_t min_bytes = static_cast<int32_t>(probe.target_data_rate.bps() *
+                                          probe.target_duration.ms() / 8000);
+  event_log->Log(absl::make_unique<RtcEventProbeClusterCreated>(
+      probe.id, probe.target_data_rate.bps(), probe.target_probe_count,
+      min_bytes));
+}
+
 }  // namespace
 
-ProbeController::ProbeController(const WebRtcKeyValueConfig* key_value_config)
+ProbeController::ProbeController(const WebRtcKeyValueConfig* key_value_config,
+                                 RtcEventLog* event_log)
     : enable_periodic_alr_probing_(false),
       in_rapid_recovery_experiment_(
           key_value_config->Lookup(kBweRapidRecoveryExperiment)
               .find("Enabled") == 0),
       limit_probes_with_allocateable_rate_(
           key_value_config->Lookup(kCappedProbingFieldTrialName)
-              .find("Disabled") != 0) {
+              .find("Disabled") != 0),
+      event_log_(event_log) {
   Reset(0);
 }
 
@@ -364,6 +382,9 @@
     config.target_data_rate = DataRate::bps(rtc::dchecked_cast<int>(bitrate));
     config.target_duration = TimeDelta::ms(kMinProbeDurationMs);
     config.target_probe_count = kMinProbePacketsSent;
+    config.id = next_probe_cluster_id_;
+    next_probe_cluster_id_++;
+    MaybeLogProbeClusterCreated(event_log_, config);
     pending_probes.push_back(config);
   }
   time_last_probing_initiated_ms_ = now_ms;
diff --git a/modules/congestion_controller/goog_cc/probe_controller.h b/modules/congestion_controller/goog_cc/probe_controller.h
index bacea0c..f937987 100644
--- a/modules/congestion_controller/goog_cc/probe_controller.h
+++ b/modules/congestion_controller/goog_cc/probe_controller.h
@@ -19,6 +19,7 @@
 #include "absl/types/optional.h"
 #include "api/transport/network_control.h"
 #include "api/transport/webrtc_key_value_config.h"
+#include "logging/rtc_event_log/rtc_event_log.h"
 #include "rtc_base/constructor_magic.h"
 #include "rtc_base/system/unused.h"
 
@@ -31,7 +32,8 @@
 // bitrate is adjusted by an application.
 class ProbeController {
  public:
-  explicit ProbeController(const WebRtcKeyValueConfig* key_value_config);
+  explicit ProbeController(const WebRtcKeyValueConfig* key_value_config,
+                           RtcEventLog* event_log);
   ~ProbeController();
 
   RTC_WARN_UNUSED_RESULT std::vector<ProbeClusterConfig> SetBitrates(
@@ -112,6 +114,9 @@
   bool mid_call_probing_waiting_for_result_;
   int64_t mid_call_probing_bitrate_bps_;
   int64_t mid_call_probing_succcess_threshold_;
+  RtcEventLog* event_log_;
+
+  int32_t next_probe_cluster_id_ = 1;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(ProbeController);
 };
diff --git a/modules/congestion_controller/goog_cc/probe_controller_unittest.cc b/modules/congestion_controller/goog_cc/probe_controller_unittest.cc
index 067aabb..112fe64 100644
--- a/modules/congestion_controller/goog_cc/probe_controller_unittest.cc
+++ b/modules/congestion_controller/goog_cc/probe_controller_unittest.cc
@@ -13,6 +13,7 @@
 #include "api/transport/network_types.h"
 #include "api/units/data_rate.h"
 #include "api/units/timestamp.h"
+#include "logging/rtc_event_log/mock/mock_rtc_event_log.h"
 #include "modules/congestion_controller/goog_cc/probe_controller.h"
 #include "system_wrappers/include/clock.h"
 #include "test/gmock.h"
@@ -44,7 +45,8 @@
 class ProbeControllerTest : public ::testing::Test {
  protected:
   ProbeControllerTest() : clock_(100000000L) {
-    probe_controller_.reset(new ProbeController(&field_trial_config_));
+    probe_controller_.reset(
+        new ProbeController(&field_trial_config_, &mock_rtc_event_log));
   }
   ~ProbeControllerTest() override {}
 
@@ -59,6 +61,7 @@
 
   FieldTrialBasedConfig field_trial_config_;
   SimulatedClock clock_;
+  MockRtcEventLog mock_rtc_event_log;
   std::unique_ptr<ProbeController> probe_controller_;
 };
 
@@ -225,7 +228,8 @@
 }
 
 TEST_F(ProbeControllerTest, PeriodicProbingAfterReset) {
-  probe_controller_.reset(new ProbeController(&field_trial_config_));
+  probe_controller_.reset(
+      new ProbeController(&field_trial_config_, &mock_rtc_event_log));
   int64_t alr_start_time = clock_.TimeInMilliseconds();
 
   probe_controller_->SetAlrStartTimeMs(alr_start_time);
diff --git a/modules/congestion_controller/send_side_congestion_controller.cc b/modules/congestion_controller/send_side_congestion_controller.cc
index f8b8dba..e41aef1 100644
--- a/modules/congestion_controller/send_side_congestion_controller.cc
+++ b/modules/congestion_controller/send_side_congestion_controller.cc
@@ -99,7 +99,7 @@
           BitrateController::CreateBitrateController(clock_, event_log)),
       acknowledged_bitrate_estimator_(
           absl::make_unique<AcknowledgedBitrateEstimator>(key_value_config_)),
-      probe_controller_(new ProbeController(key_value_config_)),
+      probe_controller_(new ProbeController(key_value_config_, event_log)),
       retransmission_rate_limiter_(
           new RateLimiter(clock, kRetransmitWindowSizeMs)),
       transport_feedback_adapter_(clock_),
@@ -341,7 +341,8 @@
 void DEPRECATED_SendSideCongestionController::SendProbes(
     std::vector<ProbeClusterConfig> probe_configs) {
   for (auto probe_config : probe_configs) {
-    pacer_->CreateProbeCluster(probe_config.target_data_rate.bps());
+    pacer_->CreateProbeCluster(probe_config.target_data_rate.bps(),
+                               probe_config.id);
   }
 }
 
diff --git a/modules/congestion_controller/send_side_congestion_controller_unittest.cc b/modules/congestion_controller/send_side_congestion_controller_unittest.cc
index 8b6e5c4..484296f 100644
--- a/modules/congestion_controller/send_side_congestion_controller_unittest.cc
+++ b/modules/congestion_controller/send_side_congestion_controller_unittest.cc
@@ -62,8 +62,8 @@
     // to be updated.
     EXPECT_CALL(observer_, OnNetworkChanged(kInitialBitrateBps, _, _, _));
     EXPECT_CALL(*pacer_, SetEstimatedBitrate(kInitialBitrateBps));
-    EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 3));
-    EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 5));
+    EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 3, 1));
+    EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 5, 2));
     controller_->SetBweBitrates(0, kInitialBitrateBps, 5 * kInitialBitrateBps);
   }
 
@@ -335,8 +335,8 @@
 
 TEST_F(LegacySendSideCongestionControllerTest, ProbeOnRouteChange) {
   testing::Mock::VerifyAndClearExpectations(pacer_.get());
-  EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 6));
-  EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 12));
+  EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 6, _));
+  EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 12, _));
   EXPECT_CALL(observer_, OnNetworkChanged(kInitialBitrateBps * 2, _, _, _));
   rtc::NetworkRoute route;
   route.local_network_id = 1;
diff --git a/modules/pacing/BUILD.gn b/modules/pacing/BUILD.gn
index 1b37168..7ebd37b 100644
--- a/modules/pacing/BUILD.gn
+++ b/modules/pacing/BUILD.gn
@@ -34,6 +34,7 @@
     "../../logging:rtc_event_log_api",
     "../../logging:rtc_event_pacing",
     "../../rtc_base:checks",
+    "../../rtc_base:deprecation",
     "../../rtc_base:rtc_base_approved",
     "../../rtc_base/experiments:alr_experiment",
     "../../rtc_base/experiments:field_trial_parser",
diff --git a/modules/pacing/bitrate_prober.cc b/modules/pacing/bitrate_prober.cc
index 4ff7c0d..890eb7b 100644
--- a/modules/pacing/bitrate_prober.cc
+++ b/modules/pacing/bitrate_prober.cc
@@ -49,11 +49,9 @@
 
 BitrateProber::~BitrateProber() = default;
 
+// TODO(psla): Remove this constructor in a follow up change.
 BitrateProber::BitrateProber(RtcEventLog* event_log)
-    : probing_state_(ProbingState::kDisabled),
-      next_probe_time_ms_(-1),
-      next_cluster_id_(0),
-      event_log_(event_log) {
+    : probing_state_(ProbingState::kDisabled), next_probe_time_ms_(-1) {
   SetEnabled(true);
 }
 
@@ -85,7 +83,9 @@
   }
 }
 
-void BitrateProber::CreateProbeCluster(int bitrate_bps, int64_t now_ms) {
+void BitrateProber::CreateProbeCluster(int bitrate_bps,
+                                       int64_t now_ms,
+                                       int cluster_id) {
   RTC_DCHECK(probing_state_ != ProbingState::kDisabled);
   RTC_DCHECK_GT(bitrate_bps, 0);
   while (!clusters_.empty() &&
@@ -100,13 +100,8 @@
       static_cast<int64_t>(bitrate_bps) * kMinProbeDurationMs / 8000);
   RTC_DCHECK_GE(cluster.pace_info.probe_cluster_min_bytes, 0);
   cluster.pace_info.send_bitrate_bps = bitrate_bps;
-  cluster.pace_info.probe_cluster_id = next_cluster_id_++;
+  cluster.pace_info.probe_cluster_id = cluster_id;
   clusters_.push(cluster);
-  if (event_log_)
-    event_log_->Log(absl::make_unique<RtcEventProbeClusterCreated>(
-        cluster.pace_info.probe_cluster_id, cluster.pace_info.send_bitrate_bps,
-        cluster.pace_info.probe_cluster_min_probes,
-        cluster.pace_info.probe_cluster_min_bytes));
 
   RTC_LOG(LS_INFO) << "Probe cluster (bitrate:min bytes:min packets): ("
                    << cluster.pace_info.send_bitrate_bps << ":"
diff --git a/modules/pacing/bitrate_prober.h b/modules/pacing/bitrate_prober.h
index bb98100..a8e964c 100644
--- a/modules/pacing/bitrate_prober.h
+++ b/modules/pacing/bitrate_prober.h
@@ -42,7 +42,7 @@
 
   // Create a cluster used to probe for |bitrate_bps| with |num_probes| number
   // of probes.
-  void CreateProbeCluster(int bitrate_bps, int64_t now_ms);
+  void CreateProbeCluster(int bitrate_bps, int64_t now_ms, int cluster_id);
 
   // Returns the number of milliseconds until the next probe should be sent to
   // get accurate probing.
@@ -98,9 +98,6 @@
 
   // Time the next probe should be sent when in kActive state.
   int64_t next_probe_time_ms_;
-
-  int next_cluster_id_;
-  RtcEventLog* const event_log_;
 };
 
 }  // namespace webrtc
diff --git a/modules/pacing/bitrate_prober_unittest.cc b/modules/pacing/bitrate_prober_unittest.cc
index a44650f..1770ac5 100644
--- a/modules/pacing/bitrate_prober_unittest.cc
+++ b/modules/pacing/bitrate_prober_unittest.cc
@@ -25,8 +25,8 @@
   const int kProbeSize = 1000;
   const int kMinProbeDurationMs = 15;
 
-  prober.CreateProbeCluster(kTestBitrate1, now_ms);
-  prober.CreateProbeCluster(kTestBitrate2, now_ms);
+  prober.CreateProbeCluster(kTestBitrate1, now_ms, 0);
+  prober.CreateProbeCluster(kTestBitrate2, now_ms, 1);
   EXPECT_FALSE(prober.IsProbing());
 
   prober.OnIncomingPacket(kProbeSize);
@@ -76,7 +76,7 @@
   int64_t now_ms = 0;
   EXPECT_EQ(-1, prober.TimeUntilNextProbe(now_ms));
 
-  prober.CreateProbeCluster(900000, now_ms);
+  prober.CreateProbeCluster(900000, now_ms, 0);
   EXPECT_FALSE(prober.IsProbing());
 
   prober.OnIncomingPacket(1000);
@@ -105,7 +105,7 @@
   BitrateProber prober;
   constexpr unsigned kHighBitrateBps = 10000000;  // 10 Mbps
 
-  prober.CreateProbeCluster(kHighBitrateBps, 0);
+  prober.CreateProbeCluster(kHighBitrateBps, 0, /*cluster_id=*/0);
   // Probe size should ensure a minimum of 1 ms interval.
   EXPECT_GT(prober.RecommendedMinProbeSize(), kHighBitrateBps / 8000);
 }
@@ -117,7 +117,7 @@
   constexpr int kBitrateBps = 100000;  // 100 kbps
   constexpr int kPacketSizeBytes = 1000;
 
-  prober.CreateProbeCluster(kBitrateBps, 0);
+  prober.CreateProbeCluster(kBitrateBps, 0, 0);
   prober.OnIncomingPacket(kPacketSizeBytes);
   for (int i = 0; i < 5; ++i) {
     EXPECT_TRUE(prober.IsProbing());
@@ -133,7 +133,7 @@
   constexpr int kPacketSizeBytes = 1000;
   constexpr int kExpectedBytesSent = kBitrateBps * 15 / 8000;
 
-  prober.CreateProbeCluster(kBitrateBps, 0);
+  prober.CreateProbeCluster(kBitrateBps, 0, /*cluster_id=*/0);
   prober.OnIncomingPacket(kPacketSizeBytes);
   int bytes_sent = 0;
   while (bytes_sent < kExpectedBytesSent) {
@@ -151,7 +151,7 @@
   constexpr int kPacketSizeBytes = 1000;
   constexpr int kExpectedBytesSent = (kBitrateBps / 8000) * 15;
 
-  prober.CreateProbeCluster(kBitrateBps, 0);
+  prober.CreateProbeCluster(kBitrateBps, 0, 0);
   prober.OnIncomingPacket(kPacketSizeBytes);
   int bytes_sent = 0;
   while (bytes_sent < kExpectedBytesSent) {
@@ -172,15 +172,15 @@
   constexpr int64_t kTimeoutMs = 5000;
 
   int64_t now_ms = 0;
-  prober.CreateProbeCluster(kBitrateBps, now_ms);
+  prober.CreateProbeCluster(kBitrateBps, now_ms, /*cluster_id=*/0);
   prober.OnIncomingPacket(kSmallPacketSize);
   EXPECT_FALSE(prober.IsProbing());
   now_ms += kTimeoutMs;
-  prober.CreateProbeCluster(kBitrateBps / 10, now_ms);
+  prober.CreateProbeCluster(kBitrateBps / 10, now_ms, /*cluster_id=*/1);
   prober.OnIncomingPacket(kSmallPacketSize);
   EXPECT_FALSE(prober.IsProbing());
   now_ms += 1;
-  prober.CreateProbeCluster(kBitrateBps / 10, now_ms);
+  prober.CreateProbeCluster(kBitrateBps / 10, now_ms, /*cluster_id=*/2);
   prober.OnIncomingPacket(kSmallPacketSize);
   EXPECT_TRUE(prober.IsProbing());
   int bytes_sent = 0;
diff --git a/modules/pacing/mock/mock_paced_sender.h b/modules/pacing/mock/mock_paced_sender.h
index 0bf102f..992c21d 100644
--- a/modules/pacing/mock/mock_paced_sender.h
+++ b/modules/pacing/mock/mock_paced_sender.h
@@ -30,7 +30,7 @@
                     int64_t capture_time_ms,
                     size_t bytes,
                     bool retransmission));
-  MOCK_METHOD1(CreateProbeCluster, void(int));
+  MOCK_METHOD2(CreateProbeCluster, void(int, int));
   MOCK_METHOD1(SetEstimatedBitrate, void(uint32_t));
   MOCK_METHOD2(SetPacingRates, void(uint32_t, uint32_t));
   MOCK_CONST_METHOD0(QueueInMs, int64_t());
diff --git a/modules/pacing/paced_sender.cc b/modules/pacing/paced_sender.cc
index 2a10b42..892b109 100644
--- a/modules/pacing/paced_sender.cc
+++ b/modules/pacing/paced_sender.cc
@@ -83,8 +83,13 @@
 PacedSender::~PacedSender() {}
 
 void PacedSender::CreateProbeCluster(int bitrate_bps) {
+  CreateProbeCluster(bitrate_bps, next_probe_cluster_id_);
+  next_probe_cluster_id_++;
+}
+
+void PacedSender::CreateProbeCluster(int bitrate_bps, int cluster_id) {
   rtc::CritScope cs(&critsect_);
-  prober_.CreateProbeCluster(bitrate_bps, TimeMilliseconds());
+  prober_.CreateProbeCluster(bitrate_bps, TimeMilliseconds(), cluster_id);
 }
 
 void PacedSender::Pause() {
diff --git a/modules/pacing/paced_sender.h b/modules/pacing/paced_sender.h
index 0ca5416..18add4a 100644
--- a/modules/pacing/paced_sender.h
+++ b/modules/pacing/paced_sender.h
@@ -25,6 +25,7 @@
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/utility/include/process_thread.h"
 #include "rtc_base/critical_section.h"
+#include "rtc_base/deprecation.h"
 #include "rtc_base/experiments/field_trial_parser.h"
 #include "rtc_base/thread_annotations.h"
 
@@ -74,7 +75,8 @@
 
   ~PacedSender() override;
 
-  virtual void CreateProbeCluster(int bitrate_bps);
+  RTC_DEPRECATED virtual void CreateProbeCluster(int bitrate_bps);
+  virtual void CreateProbeCluster(int bitrate_bps, int cluster_id);
 
   // Temporarily pause all sending.
   void Pause();
@@ -206,6 +208,9 @@
   RoundRobinPacketQueue packets_ RTC_GUARDED_BY(critsect_);
   uint64_t packet_counter_ RTC_GUARDED_BY(critsect_);
 
+  // TODO(psla): Used by the RTC_DEPRECATED method, to be removed.
+  int next_probe_cluster_id_ = 1;
+
   int64_t congestion_window_bytes_ RTC_GUARDED_BY(critsect_) =
       kNoCongestionWindow;
   int64_t outstanding_bytes_ RTC_GUARDED_BY(critsect_) = 0;
diff --git a/modules/pacing/paced_sender_unittest.cc b/modules/pacing/paced_sender_unittest.cc
index fb79ebc..158a5fb 100644
--- a/modules/pacing/paced_sender_unittest.cc
+++ b/modules/pacing/paced_sender_unittest.cc
@@ -112,8 +112,8 @@
     srand(0);
     // Need to initialize PacedSender after we initialize clock.
     send_bucket_.reset(new PacedSender(&clock_, &callback_, nullptr));
-    send_bucket_->CreateProbeCluster(kFirstClusterBps);
-    send_bucket_->CreateProbeCluster(kSecondClusterBps);
+    send_bucket_->CreateProbeCluster(kFirstClusterBps, /*cluster_id=*/0);
+    send_bucket_->CreateProbeCluster(kSecondClusterBps, /*cluster_id=*/1);
     // Default to bitrate probing disabled for testing purposes. Probing tests
     // have to enable probing, either by creating a new PacedSender instance or
     // by calling SetProbingEnabled(true).
@@ -1055,8 +1055,8 @@
 
   PacedSenderProbing packet_sender;
   send_bucket_.reset(new PacedSender(&clock_, &packet_sender, nullptr));
-  send_bucket_->CreateProbeCluster(kFirstClusterBps);
-  send_bucket_->CreateProbeCluster(kSecondClusterBps);
+  send_bucket_->CreateProbeCluster(kFirstClusterBps, /*cluster_id=*/0);
+  send_bucket_->CreateProbeCluster(kSecondClusterBps, /*cluster_id=*/1);
   send_bucket_->SetPacingRates(kInitialBitrateBps * kPaceMultiplier, 0);
 
   for (int i = 0; i < 10; ++i) {
@@ -1101,7 +1101,7 @@
 
   PacedSenderProbing packet_sender;
   send_bucket_.reset(new PacedSender(&clock_, &packet_sender, nullptr));
-  send_bucket_->CreateProbeCluster(kFirstClusterBps);
+  send_bucket_->CreateProbeCluster(kFirstClusterBps, /*cluster_id=*/0);
   send_bucket_->SetPacingRates(kInitialBitrateBps * kPaceMultiplier, 0);
 
   for (int i = 0; i < 3; ++i) {