diff --git a/logging/BUILD.gn b/logging/BUILD.gn
index 67c01fa..ce40528 100644
--- a/logging/BUILD.gn
+++ b/logging/BUILD.gn
@@ -37,6 +37,7 @@
   sources = [
     "rtc_event_log/events/fixed_length_encoding_parameters_v3.cc",
     "rtc_event_log/events/fixed_length_encoding_parameters_v3.h",
+    "rtc_event_log/events/rtc_event_definition.h",
     "rtc_event_log/events/rtc_event_field_encoding.cc",
     "rtc_event_log/events/rtc_event_field_encoding.h",
     "rtc_event_log/events/rtc_event_field_encoding_parser.cc",
@@ -291,6 +292,7 @@
       ":rtc_event_audio",
       ":rtc_event_begin_end",
       ":rtc_event_bwe",
+      ":rtc_event_field",
       ":rtc_event_frame_events",
       ":rtc_event_generic_packet_events",
       ":rtc_event_log2_proto",
@@ -310,6 +312,8 @@
       "rtc_event_log/encoder/rtc_event_log_encoder_legacy.h",
       "rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc",
       "rtc_event_log/encoder/rtc_event_log_encoder_new_format.h",
+      "rtc_event_log/encoder/rtc_event_log_encoder_v3.cc",
+      "rtc_event_log/encoder/rtc_event_log_encoder_v3.h",
     ]
   }
 }
diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
index bd898a1..be9352a 100644
--- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
@@ -16,6 +16,7 @@
 
 #include "logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.h"
 #include "logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h"
+#include "logging/rtc_event_log/encoder/rtc_event_log_encoder_v3.h"
 #include "logging/rtc_event_log/events/rtc_event_alr_state.h"
 #include "logging/rtc_event_log/events/rtc_event_audio_network_adaptation.h"
 #include "logging/rtc_event_log/events/rtc_event_audio_playout.h"
@@ -62,8 +63,7 @@
         encoder_ = std::make_unique<RtcEventLogEncoderNewFormat>();
         break;
       case RtcEventLog::EncodingType::ProtoFree:
-        // TODO(terelius): Enable test once the format has been wired up.
-        RTC_CHECK_NOTREACHED();
+        encoder_ = std::make_unique<RtcEventLogEncoderV3>();
         break;
     }
     encoded_ =
@@ -1290,8 +1290,7 @@
         encoder_ = std::make_unique<RtcEventLogEncoderNewFormat>();
         break;
       case RtcEventLog::EncodingType::ProtoFree:
-        // TODO(terelius): Enable test once the format has been wired up.
-        RTC_CHECK_NOTREACHED();
+        encoder_ = std::make_unique<RtcEventLogEncoderV3>();
         break;
     }
     encoded_ =
diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_v3.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_v3.cc
new file mode 100644
index 0000000..1fd5fa6
--- /dev/null
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_v3.cc
@@ -0,0 +1,117 @@
+/*
+ *  Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "logging/rtc_event_log/encoder/rtc_event_log_encoder_v3.h"
+
+#include <string>
+#include <vector>
+
+#include "absl/types/optional.h"
+#include "logging/rtc_event_log/encoder/rtc_event_log_encoder_common.h"
+#include "logging/rtc_event_log/encoder/var_int.h"
+#include "logging/rtc_event_log/events/rtc_event_alr_state.h"
+#include "logging/rtc_event_log/events/rtc_event_audio_network_adaptation.h"
+#include "logging/rtc_event_log/events/rtc_event_audio_playout.h"
+#include "logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.h"
+#include "logging/rtc_event_log/events/rtc_event_audio_send_stream_config.h"
+#include "logging/rtc_event_log/events/rtc_event_begin_log.h"
+#include "logging/rtc_event_log/events/rtc_event_bwe_update_delay_based.h"
+#include "logging/rtc_event_log/events/rtc_event_bwe_update_loss_based.h"
+#include "logging/rtc_event_log/events/rtc_event_dtls_transport_state.h"
+#include "logging/rtc_event_log/events/rtc_event_dtls_writable_state.h"
+#include "logging/rtc_event_log/events/rtc_event_end_log.h"
+#include "logging/rtc_event_log/events/rtc_event_frame_decoded.h"
+#include "logging/rtc_event_log/events/rtc_event_generic_ack_received.h"
+#include "logging/rtc_event_log/events/rtc_event_generic_packet_received.h"
+#include "logging/rtc_event_log/events/rtc_event_generic_packet_sent.h"
+#include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair.h"
+#include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair_config.h"
+#include "logging/rtc_event_log/events/rtc_event_probe_cluster_created.h"
+#include "logging/rtc_event_log/events/rtc_event_probe_result_failure.h"
+#include "logging/rtc_event_log/events/rtc_event_probe_result_success.h"
+#include "logging/rtc_event_log/events/rtc_event_remote_estimate.h"
+#include "logging/rtc_event_log/events/rtc_event_route_change.h"
+#include "logging/rtc_event_log/events/rtc_event_rtcp_packet_incoming.h"
+#include "logging/rtc_event_log/events/rtc_event_rtcp_packet_outgoing.h"
+#include "logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.h"
+#include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h"
+#include "logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h"
+#include "logging/rtc_event_log/events/rtc_event_video_send_stream_config.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/logging.h"
+
+namespace webrtc {
+
+std::string RtcEventLogEncoderV3::EncodeLogStart(int64_t timestamp_us,
+                                                 int64_t utc_time_us) {
+  std::unique_ptr<RtcEventBeginLog> begin_log =
+      std::make_unique<RtcEventBeginLog>(Timestamp::Micros(timestamp_us),
+                                         Timestamp::Micros(utc_time_us));
+  std::vector<const RtcEvent*> batch;
+  batch.push_back(begin_log.get());
+
+  std::string encoded_event = RtcEventBeginLog::Encode(batch);
+
+  return encoded_event;
+}
+
+std::string RtcEventLogEncoderV3::EncodeLogEnd(int64_t timestamp_us) {
+  std::unique_ptr<RtcEventEndLog> end_log =
+      std::make_unique<RtcEventEndLog>(Timestamp::Micros(timestamp_us));
+  std::vector<const RtcEvent*> batch;
+  batch.push_back(end_log.get());
+
+  std::string encoded_event = RtcEventEndLog::Encode(batch);
+
+  return encoded_event;
+}
+
+RtcEventLogEncoderV3::RtcEventLogEncoderV3() {
+  encoders_[RtcEvent::Type::AlrStateEvent] = RtcEventAlrState::Encode;
+}
+
+std::string RtcEventLogEncoderV3::EncodeBatch(
+    std::deque<std::unique_ptr<RtcEvent>>::const_iterator begin,
+    std::deque<std::unique_ptr<RtcEvent>>::const_iterator end) {
+  struct EventGroupKey {
+    // Events are grouped by event type. For compression efficiency,
+    // events can optionally have a secondary key, in most cases the
+    // SSRC.
+    RtcEvent::Type type;
+    uint32_t secondary_group_key;
+
+    bool operator<(EventGroupKey other) const {
+      return type < other.type ||
+             (type == other.type &&
+              secondary_group_key < other.secondary_group_key);
+    }
+  };
+
+  std::map<EventGroupKey, std::vector<const RtcEvent*>> event_groups;
+
+  for (auto it = begin; it != end; ++it) {
+    event_groups[{(*it)->GetType(), (*it)->GetGroupKey()}].push_back(it->get());
+  }
+
+  std::string encoded_output;
+  for (auto& kv : event_groups) {
+    auto it = encoders_.find(kv.first.type);
+    RTC_DCHECK(it != encoders_.end());
+    if (it != encoders_.end()) {
+      auto& encoder = it->second;
+      // TODO(terelius): Use some "string builder" or preallocate?
+      encoded_output += encoder(kv.second);
+    }
+  }
+
+  return encoded_output;
+}
+
+}  // namespace webrtc
diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_v3.h b/logging/rtc_event_log/encoder/rtc_event_log_encoder_v3.h
new file mode 100644
index 0000000..cb796ec
--- /dev/null
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_v3.h
@@ -0,0 +1,46 @@
+/*
+ *  Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef LOGGING_RTC_EVENT_LOG_ENCODER_RTC_EVENT_LOG_ENCODER_V3_H_
+#define LOGGING_RTC_EVENT_LOG_ENCODER_RTC_EVENT_LOG_ENCODER_V3_H_
+
+#include <deque>
+#include <map>
+#include <memory>
+#include <string>
+
+#include "api/array_view.h"
+#include "logging/rtc_event_log/encoder/rtc_event_log_encoder.h"
+#include "logging/rtc_event_log/events/rtc_event_definition.h"
+
+namespace webrtc {
+
+class RtcEventLogEncoderV3 final : public RtcEventLogEncoder {
+ public:
+  RtcEventLogEncoderV3();
+  ~RtcEventLogEncoderV3() override = default;
+
+  std::string EncodeBatch(
+      std::deque<std::unique_ptr<RtcEvent>>::const_iterator begin,
+      std::deque<std::unique_ptr<RtcEvent>>::const_iterator end) override;
+
+  std::string EncodeLogStart(int64_t timestamp_us,
+                             int64_t utc_time_us) override;
+  std::string EncodeLogEnd(int64_t timestamp_us) override;
+
+ private:
+  std::map<RtcEvent::Type,
+           std::function<std::string(rtc::ArrayView<const RtcEvent*>)>>
+      encoders_;
+};
+
+}  // namespace webrtc
+
+#endif  // LOGGING_RTC_EVENT_LOG_ENCODER_RTC_EVENT_LOG_ENCODER_V3_H_
diff --git a/logging/rtc_event_log/events/rtc_event_alr_state.cc b/logging/rtc_event_log/events/rtc_event_alr_state.cc
index 3c307b9..25941eb 100644
--- a/logging/rtc_event_log/events/rtc_event_alr_state.cc
+++ b/logging/rtc_event_log/events/rtc_event_alr_state.cc
@@ -13,6 +13,9 @@
 #include "absl/memory/memory.h"
 
 namespace webrtc {
+constexpr RtcEvent::Type RtcEventAlrState::kType;
+constexpr RtcEventDefinition<RtcEventAlrState, LoggedAlrStateEvent, bool>
+    RtcEventAlrState::definition_;
 
 RtcEventAlrState::RtcEventAlrState(bool in_alr) : in_alr_(in_alr) {}
 
@@ -25,4 +28,11 @@
   return absl::WrapUnique<RtcEventAlrState>(new RtcEventAlrState(*this));
 }
 
+RtcEventLogParseStatus RtcEventAlrState::Parse(
+    absl::string_view s,
+    bool batched,
+    std::vector<LoggedAlrStateEvent>& output) {
+  return RtcEventAlrState::definition_.ParseBatch(s, batched, output);
+}
+
 }  // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_alr_state.h b/logging/rtc_event_log/events/rtc_event_alr_state.h
index 74d6601..2bc7408 100644
--- a/logging/rtc_event_log/events/rtc_event_alr_state.h
+++ b/logging/rtc_event_log/events/rtc_event_alr_state.h
@@ -12,12 +12,30 @@
 #define LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_ALR_STATE_H_
 
 #include <memory>
+#include <string>
+#include <vector>
 
 #include "api/rtc_event_log/rtc_event.h"
 #include "api/units/timestamp.h"
+#include "logging/rtc_event_log/events/rtc_event_definition.h"
+#include "logging/rtc_event_log/events/rtc_event_field_encoding.h"
+#include "logging/rtc_event_log/events/rtc_event_field_encoding_parser.h"
+#include "logging/rtc_event_log/events/rtc_event_field_extraction.h"
 
 namespace webrtc {
 
+struct LoggedAlrStateEvent {
+  LoggedAlrStateEvent() = default;
+  LoggedAlrStateEvent(Timestamp timestamp, bool in_alr)
+      : timestamp(timestamp), in_alr(in_alr) {}
+
+  int64_t log_time_us() const { return timestamp.us(); }
+  int64_t log_time_ms() const { return timestamp.ms(); }
+
+  Timestamp timestamp = Timestamp::MinusInfinity();
+  bool in_alr;
+};
+
 class RtcEventAlrState final : public RtcEvent {
  public:
   static constexpr Type kType = Type::AlrStateEvent;
@@ -32,22 +50,26 @@
 
   bool in_alr() const { return in_alr_; }
 
+  static std::string Encode(rtc::ArrayView<const RtcEvent*> batch) {
+    return RtcEventAlrState::definition_.EncodeBatch(batch);
+  }
+
+  static RtcEventLogParseStatus Parse(absl::string_view s,
+                                      bool batched,
+                                      std::vector<LoggedAlrStateEvent>& output);
+
  private:
   RtcEventAlrState(const RtcEventAlrState& other);
 
   const bool in_alr_;
-};
 
-struct LoggedAlrStateEvent {
-  LoggedAlrStateEvent() = default;
-  LoggedAlrStateEvent(Timestamp timestamp, bool in_alr)
-      : timestamp(timestamp), in_alr(in_alr) {}
-
-  int64_t log_time_us() const { return timestamp.us(); }
-  int64_t log_time_ms() const { return timestamp.ms(); }
-
-  Timestamp timestamp = Timestamp::MinusInfinity();
-  bool in_alr;
+  static constexpr RtcEventDefinition<RtcEventAlrState,
+                                      LoggedAlrStateEvent,
+                                      bool>
+      definition_{{"AlrState", RtcEventAlrState::kType},
+                  {&RtcEventAlrState::in_alr_,
+                   &LoggedAlrStateEvent::in_alr,
+                   {"in_alr", /*id=*/1, FieldType::kFixed8, /*width=*/1}}};
 };
 
 }  // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_definition.h b/logging/rtc_event_log/events/rtc_event_definition.h
new file mode 100644
index 0000000..43dd7eb
--- /dev/null
+++ b/logging/rtc_event_log/events/rtc_event_definition.h
@@ -0,0 +1,149 @@
+/*
+ *  Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_DEFINITION_H_
+#define LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_DEFINITION_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "api/array_view.h"
+#include "api/units/timestamp.h"
+#include "logging/rtc_event_log/events/rtc_event_field_encoding.h"
+#include "logging/rtc_event_log/events/rtc_event_field_encoding_parser.h"
+#include "logging/rtc_event_log/events/rtc_event_field_extraction.h"
+#include "rtc_base/logging.h"
+
+namespace webrtc {
+
+template <typename EventType, typename LoggedType, typename T>
+struct RtcEventFieldDefinition {
+  const T EventType::*event_member;
+  T LoggedType::*logged_member;
+  FieldParameters params;
+};
+
+// Base case
+template <typename EventType, typename LoggedType, typename... Ts>
+class RtcEventDefinitionImpl {
+ public:
+  void EncodeImpl(EventEncoder&, rtc::ArrayView<const RtcEvent*>) const {}
+  RtcEventLogParseStatus ParseImpl(EventParser&,
+                                   rtc::ArrayView<LoggedType>) const {
+    return RtcEventLogParseStatus::Success();
+  }
+};
+
+// Recursive case
+template <typename EventType, typename LoggedType, typename T, typename... Ts>
+class RtcEventDefinitionImpl<EventType, LoggedType, T, Ts...> {
+ public:
+  constexpr RtcEventDefinitionImpl(
+      RtcEventFieldDefinition<EventType, LoggedType, T> field,
+      RtcEventFieldDefinition<EventType, LoggedType, Ts>... rest)
+      : field_(field), rest_(rest...) {}
+
+  void EncodeImpl(EventEncoder& encoder,
+                  rtc::ArrayView<const RtcEvent*> batch) const {
+    auto values = ExtractRtcEventMember(batch, field_.event_member);
+    encoder.EncodeField(field_.params, values);
+    rest_.EncodeImpl(encoder, batch);
+  }
+
+  RtcEventLogParseStatus ParseImpl(
+      EventParser& parser,
+      rtc::ArrayView<LoggedType> output_batch) const {
+    RtcEventLogParseStatusOr<rtc::ArrayView<uint64_t>> result =
+        parser.ParseNumericField(field_.params);
+    if (!result.ok())
+      return result.status();
+    PopulateRtcEventMember(result.value(), field_.logged_member, output_batch);
+
+    return rest_.ParseImpl(parser, output_batch);
+  }
+
+ private:
+  RtcEventFieldDefinition<EventType, LoggedType, T> field_;
+  RtcEventDefinitionImpl<EventType, LoggedType, Ts...> rest_;
+};
+
+// The RtcEventDefinition sets up a mapping between the fields
+// in an RtcEvent and the corresponding fields in the parsed struct.
+// For example, an RtcFoo class containing two fields; `uint32_t bar`
+// and `bool baz` (a log timestamp is always implicitly added)
+// might have a definition
+// RtcEventDefinition<RtcFoo, LoggedFoo, uint32_t, bool>(
+//   {"foo", RtcFoo::Type},
+//   {&RtcFoo::bar_, &LoggedFoo::bar, {"bar", 1, FieldType::kVarInt, 32}},
+//   {&RtcFoo::baz_, &LoggedFoo::baz, {"baz", 2, FieldType::kFixed8, 1}},
+// );
+// In addition to defining string names to aid debugging,
+// this specifies that
+// * RtcFoo::Type uniquely identifies an RtcFoo in the encoded stream
+// * The `bar` field has ID 1, is encoded as a VarInt
+//   (when not delta compressed), and wraps around after 32 bits.
+// * The `baz` field has ID 2, is encoded as an 8-bit field
+//   (when not delta compressed), and wraps around after 1 bit.
+// Note that the numerical field and event IDs can't be changed since
+// that would break compatibility with old logs.
+// In most cases (including all cases where wrap around isn't
+// expected), the wrap around should be equal to the bitwidth of
+// the field.
+template <typename EventType, typename LoggedType, typename... Ts>
+class RtcEventDefinition {
+ public:
+  constexpr RtcEventDefinition(
+      EventParameters params,
+      RtcEventFieldDefinition<EventType, LoggedType, Ts>... fields)
+      : params_(params), fields_(fields...) {}
+
+  std::string EncodeBatch(rtc::ArrayView<const RtcEvent*> batch) const {
+    EventEncoder encoder(params_, batch);
+    fields_.EncodeImpl(encoder, batch);
+    return encoder.AsString();
+  }
+
+  RtcEventLogParseStatus ParseBatch(absl::string_view s,
+                                    bool batched,
+                                    std::vector<LoggedType>& output) const {
+    EventParser parser;
+    auto status = parser.Initialize(s, batched);
+    if (!status.ok())
+      return status;
+
+    rtc::ArrayView<LoggedType> output_batch =
+        ExtendLoggedBatch(output, parser.NumEventsInBatch());
+
+    constexpr FieldParameters timestamp_params{"timestamp_ms",
+                                               FieldParameters::kTimestampField,
+                                               FieldType::kVarInt, 64};
+    RtcEventLogParseStatusOr<rtc::ArrayView<uint64_t>> result =
+        parser.ParseNumericField(timestamp_params);
+    if (!result.ok())
+      return result.status();
+    PopulateRtcEventTimestamp(result.value(), &LoggedType::timestamp,
+                              output_batch);
+
+    return fields_.ParseImpl(parser, output_batch);
+
+    return RtcEventLogParseStatus::Success();
+  }
+
+ private:
+  EventParameters params_;
+  RtcEventDefinitionImpl<EventType, LoggedType, Ts...> fields_;
+};
+
+}  // namespace webrtc
+
+#endif  // LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_DEFINITION_H_
diff --git a/logging/rtc_event_log/rtc_event_log_parser.cc b/logging/rtc_event_log/rtc_event_log_parser.cc
index 3b3eb18..7e114a2 100644
--- a/logging/rtc_event_log/rtc_event_log_parser.cc
+++ b/logging/rtc_event_log/rtc_event_log_parser.cc
@@ -53,6 +53,12 @@
       return ParsedRtcEventLog::ParseStatus::Error(#X, __FILE__, __LINE__); \
   } while (0)
 
+#define RTC_PARSE_CHECK_OR_RETURN_MESSAGE(X, M)                              \
+  do {                                                                       \
+    if (!(X))                                                                \
+      return ParsedRtcEventLog::ParseStatus::Error((M), __FILE__, __LINE__); \
+  } while (0)
+
 #define RTC_PARSE_CHECK_OR_RETURN_OP(OP, X, Y)                          \
   do {                                                                  \
     if (!((X)OP(Y)))                                                    \
@@ -1267,18 +1273,34 @@
 ParsedRtcEventLog::ParseStatus ParsedRtcEventLog::ParseStreamInternal(
     absl::string_view s) {
   constexpr uint64_t kMaxEventSize = 10000000;  // Sanity check.
+  // Protobuf defines the message tag as
+  // (field_number << 3) | wire_type. In the legacy encoding, the field number
+  // is supposed to be 1 and the wire type for a length-delimited field is 2.
+  // In the new encoding we still expect the wire type to be 2, but the field
+  // number will be greater than 1.
+  constexpr uint64_t kExpectedV1Tag = (1 << 3) | 2;
+  bool success = false;
+
+  // "Peek" at the first varint.
+  absl::string_view event_start = s;
+  uint64_t tag = 0;
+  std::tie(success, std::ignore) = DecodeVarInt(s, &tag);
+  if (!success) {
+    RTC_LOG(LS_WARNING) << "Failed to read varint from beginning of event log.";
+    RTC_PARSE_WARN_AND_RETURN_SUCCESS_IF(allow_incomplete_logs_,
+                                         kIncompleteLogError);
+    return ParseStatus::Error("Failed to read field tag varint", __FILE__,
+                              __LINE__);
+  }
+  s = event_start;
+
+  if (tag >> 1 == static_cast<uint64_t>(RtcEvent::Type::BeginV3Log)) {
+    return ParseStreamInternalV3(s);
+  }
 
   while (!s.empty()) {
-    absl::string_view event_start = s;
-    bool success = false;
-
-    // Read the next message tag. Protobuf defines the message tag as
-    // (field_number << 3) | wire_type. In the legacy encoding, the field number
-    // is supposed to be 1 and the wire type for a length-delimited field is 2.
-    // In the new encoding we still expect the wire type to be 2, but the field
-    // number will be greater than 1.
-    constexpr uint64_t kExpectedV1Tag = (1 << 3) | 2;
-    uint64_t tag = 0;
+    // If not, "reset" event_start and read the field tag for the next event.
+    event_start = s;
     std::tie(success, s) = DecodeVarInt(s, &tag);
     if (!success) {
       RTC_LOG(LS_WARNING)
@@ -1288,6 +1310,7 @@
       return ParseStatus::Error("Failed to read field tag varint", __FILE__,
                                 __LINE__);
     }
+
     constexpr uint64_t kWireTypeMask = 0x07;
     const uint64_t wire_type = tag & kWireTypeMask;
     if (wire_type != 2) {
@@ -1357,6 +1380,58 @@
   return ParseStatus::Success();
 }
 
+ParsedRtcEventLog::ParseStatus ParsedRtcEventLog::ParseStreamInternalV3(
+    absl::string_view s) {
+  constexpr uint64_t kMaxEventSize = 10000000;  // Sanity check.
+  bool expect_begin_log_event = true;
+  bool success = false;
+
+  while (!s.empty()) {
+    // Read event type.
+    uint64_t event_tag = 0;
+    std::tie(success, s) = DecodeVarInt(s, &event_tag);
+    RTC_PARSE_CHECK_OR_RETURN_MESSAGE(success, "Failed to read event type.");
+    bool batched = event_tag & 1;
+    uint64_t event_type = event_tag >> 1;
+
+    // Read event size
+    uint64_t event_size_bytes = 0;
+    std::tie(success, s) = DecodeVarInt(s, &event_size_bytes);
+    RTC_PARSE_CHECK_OR_RETURN_MESSAGE(success, "Failed to read event size.");
+    if (event_size_bytes > kMaxEventSize || event_size_bytes > s.size()) {
+      RTC_LOG(LS_WARNING) << "Event size is too large.";
+      RTC_PARSE_CHECK_OR_RETURN_LE(event_size_bytes, kMaxEventSize);
+      RTC_PARSE_CHECK_OR_RETURN_LE(event_size_bytes, s.size());
+    }
+
+    // Read remaining event fields into a buffer.
+    absl::string_view event_fields = s.substr(0, event_size_bytes);
+    s = s.substr(event_size_bytes);
+
+    if (expect_begin_log_event) {
+      RTC_PARSE_CHECK_OR_RETURN_EQ(
+          event_type, static_cast<uint32_t>(RtcEvent::Type::BeginV3Log));
+      expect_begin_log_event = false;
+    }
+
+    switch (event_type) {
+      case static_cast<uint32_t>(RtcEvent::Type::BeginV3Log):
+        RtcEventBeginLog::Parse(event_fields, batched, start_log_events_);
+        break;
+      case static_cast<uint32_t>(RtcEvent::Type::EndV3Log):
+        RtcEventEndLog::Parse(event_fields, batched, stop_log_events_);
+        expect_begin_log_event = true;
+        break;
+      case static_cast<uint32_t>(RtcEvent::Type::AlrStateEvent):
+        RtcEventAlrState::Parse(event_fields, batched, alr_state_events_);
+        break;
+        // ADD NEW EVENTS HERE
+    }
+  }
+
+  return ParseStatus::Success();
+}
+
 template <typename T>
 void ParsedRtcEventLog::StoreFirstAndLastTimestamp(const std::vector<T>& v) {
   if (v.empty())
diff --git a/logging/rtc_event_log/rtc_event_log_parser.h b/logging/rtc_event_log/rtc_event_log_parser.h
index bbd8df2..a51b91c 100644
--- a/logging/rtc_event_log/rtc_event_log_parser.h
+++ b/logging/rtc_event_log/rtc_event_log_parser.h
@@ -584,6 +584,7 @@
 
  private:
   ABSL_MUST_USE_RESULT ParseStatus ParseStreamInternal(absl::string_view s);
+  ABSL_MUST_USE_RESULT ParseStatus ParseStreamInternalV3(absl::string_view s);
 
   ABSL_MUST_USE_RESULT ParseStatus
   StoreParsedLegacyEvent(const rtclog::Event& event);