diff --git a/aos/events/logging/BUILD b/aos/events/logging/BUILD
index 3b5f57a..5d8c1b0 100644
--- a/aos/events/logging/BUILD
+++ b/aos/events/logging/BUILD
@@ -260,6 +260,7 @@
         "//aos:configuration_fbs",
         "//aos:flatbuffers",
         "//aos/containers:resizeable_buffer",
+        "//aos/time",
         "@com_github_google_flatbuffers//:flatbuffers",
         "@com_github_google_glog//:glog",
         "@com_google_absl//absl/types:span",
@@ -434,6 +435,7 @@
         "//aos/events:event_loop",
         "//aos/events:simulated_event_loop",
         "//aos/network:message_bridge_server_fbs",
+        "@com_google_absl//absl/strings",
     ],
 )
 
@@ -1023,3 +1025,33 @@
         "@com_github_google_glog//:glog",
     ],
 )
+
+py_binary(
+    name = "plot_logger_profile",
+    srcs = [
+        "plot_logger_profile.py",
+    ],
+    target_compatible_with = [
+        # TODO(PRO-24640): Remove compatibility.
+        "@platforms//cpu:x86_64",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        "@pip//bokeh",
+        "@pip//numpy",
+        "@pip//tabulate",
+    ],
+)
+
+py_test(
+    name = "plot_logger_profile_test",
+    srcs = [
+        "plot_logger_profile_test.py",
+    ],
+    target_compatible_with = ["@platforms//os:linux"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":plot_logger_profile",
+        "@pip//numpy",
+    ],
+)
diff --git a/aos/events/logging/buffer_encoder.cc b/aos/events/logging/buffer_encoder.cc
index 6aba79a..b352d5d 100644
--- a/aos/events/logging/buffer_encoder.cc
+++ b/aos/events/logging/buffer_encoder.cc
@@ -22,7 +22,8 @@
 
 bool DummyEncoder::HasSpace(size_t request) const { return request <= space(); }
 
-size_t DummyEncoder::Encode(Copier *copy, size_t start_byte) {
+size_t DummyEncoder::Encode(Copier *copy, size_t start_byte,
+                            std::chrono::nanoseconds * /*encode_duration*/) {
   const size_t input_buffer_initial_size = input_buffer_.size();
 
   size_t expected_write_size =
diff --git a/aos/events/logging/buffer_encoder.h b/aos/events/logging/buffer_encoder.h
index a155bb5..db09d32 100644
--- a/aos/events/logging/buffer_encoder.h
+++ b/aos/events/logging/buffer_encoder.h
@@ -7,6 +7,7 @@
 
 #include "aos/containers/resizeable_buffer.h"
 #include "aos/events/logging/logger_generated.h"
+#include "aos/time/time.h"
 
 namespace aos::logger {
 
@@ -65,14 +66,19 @@
 
   // Encodes and enqueues the given data encoder.  Starts at the start byte
   // (which must be a multiple of 8 bytes), and goes as far as it can.  Returns
-  // the amount encoded.
-  virtual size_t Encode(Copier *copy, size_t start_byte) = 0;
+  // the amount encoded. The `encode_duration` is optional, when provided it
+  // will be set to the amount of time spent by the encoder during this call.
+  virtual size_t Encode(
+      Copier *copy, size_t start_byte,
+      std::chrono::nanoseconds *encode_duration = nullptr) = 0;
 
   // Finalizes the encoding process. After this, queue_size() represents the
   // full extent of data which will be written to this file.
-  //
-  // Encode may not be called after this method.
-  virtual void Finish() = 0;
+  // This function may invoke the encoder to encode any remaining data remaining
+  // in the queue. The `encode_duration` is optional, when provided it will be
+  // set to the amount of time spent by the encoder during this call. Do not
+  // call Encode after calling this method.
+  virtual void Finish(std::chrono::nanoseconds *encode_duration = nullptr) = 0;
 
   // Clears the first n encoded buffers from the queue.
   virtual void Clear(int n) = 0;
@@ -105,8 +111,11 @@
 
   bool HasSpace(size_t request) const final;
   size_t space() const final;
-  size_t Encode(Copier *copy, size_t start_byte) final;
-  void Finish() final {}
+
+  // See base class for commments.
+  size_t Encode(Copier *copy, size_t start_byte,
+                std::chrono::nanoseconds *encode_duration = nullptr) final;
+  void Finish(std::chrono::nanoseconds * /*encode_duration*/ = nullptr) final {}
   void Clear(int n) final;
   absl::Span<const absl::Span<const uint8_t>> queue() final;
   size_t queued_bytes() const final;
diff --git a/aos/events/logging/log_backend.h b/aos/events/logging/log_backend.h
index 91f048c..4eca13f 100644
--- a/aos/events/logging/log_backend.h
+++ b/aos/events/logging/log_backend.h
@@ -30,6 +30,12 @@
   std::chrono::nanoseconds total_write_time() const {
     return total_write_time_;
   }
+
+  // The total time spent encoding.
+  std::chrono::nanoseconds total_encode_duration() const {
+    return total_encode_duration_;
+  }
+
   // The total number of writes which have been performed.
   int total_write_count() const { return total_write_count_; }
   // The total number of messages which have been written.
@@ -45,9 +51,10 @@
     total_write_count_ = 0;
     total_write_messages_ = 0;
     total_write_bytes_ = 0;
+    total_encode_duration_ = std::chrono::nanoseconds::zero();
   }
 
-  void UpdateStats(aos::monotonic_clock::duration duration, ssize_t written,
+  void UpdateStats(std::chrono::nanoseconds duration, ssize_t written,
                    int iovec_size) {
     if (duration > max_write_time_) {
       max_write_time_ = duration;
@@ -60,11 +67,20 @@
     total_write_bytes_ += written;
   }
 
+  // Update our total_encode_duration_ stat. This needs to be a separate
+  // function from UpdateStats because it's called from a different level in the
+  // stack.
+  void UpdateEncodeDuration(std::chrono::nanoseconds duration) {
+    total_encode_duration_ += duration;
+  }
+
  private:
   std::chrono::nanoseconds max_write_time_ = std::chrono::nanoseconds::zero();
   int max_write_time_bytes_ = -1;
   int max_write_time_messages_ = -1;
   std::chrono::nanoseconds total_write_time_ = std::chrono::nanoseconds::zero();
+  std::chrono::nanoseconds total_encode_duration_ =
+      std::chrono::nanoseconds::zero();
   int total_write_count_ = 0;
   int total_write_messages_ = 0;
   int total_write_bytes_ = 0;
diff --git a/aos/events/logging/log_namer.cc b/aos/events/logging/log_namer.cc
index 3d52070..6c88d89 100644
--- a/aos/events/logging/log_namer.cc
+++ b/aos/events/logging/log_namer.cc
@@ -231,13 +231,13 @@
   }
 }
 
-void NewDataWriter::CopyDataMessage(
+std::chrono::nanoseconds NewDataWriter::CopyDataMessage(
     DataEncoder::Copier *coppier, const UUID &source_node_boot_uuid,
     aos::monotonic_clock::time_point now,
     aos::monotonic_clock::time_point message_time) {
   CHECK(allowed_data_types_[static_cast<size_t>(StoredDataType::DATA)])
       << ": Tried to write data on non-data writer.";
-  CopyMessage(coppier, source_node_boot_uuid, now, message_time);
+  return CopyMessage(coppier, source_node_boot_uuid, now, message_time);
 }
 
 void NewDataWriter::CopyTimestampMessage(
@@ -259,10 +259,10 @@
   CopyMessage(coppier, source_node_boot_uuid, now, message_time);
 }
 
-void NewDataWriter::CopyMessage(DataEncoder::Copier *coppier,
-                                const UUID &source_node_boot_uuid,
-                                aos::monotonic_clock::time_point now,
-                                aos::monotonic_clock::time_point message_time) {
+std::chrono::nanoseconds NewDataWriter::CopyMessage(
+    DataEncoder::Copier *coppier, const UUID &source_node_boot_uuid,
+    aos::monotonic_clock::time_point now,
+    aos::monotonic_clock::time_point message_time) {
   // Trigger a reboot if we detect the boot UUID change.
   UpdateBoot(source_node_boot_uuid);
 
@@ -340,7 +340,8 @@
   CHECK(header_written_) << ": Attempting to write message before header to "
                          << writer->name();
   CHECK_LE(coppier->size(), max_message_size_);
-  writer->CopyMessage(coppier, now);
+  std::chrono::nanoseconds encode_duration = writer->CopyMessage(coppier, now);
+  return encode_duration;
 }
 
 aos::SizePrefixedFlatbufferDetachedBuffer<LogFileHeader>
diff --git a/aos/events/logging/log_namer.h b/aos/events/logging/log_namer.h
index a0d5857..d7c97ae 100644
--- a/aos/events/logging/log_namer.h
+++ b/aos/events/logging/log_namer.h
@@ -76,11 +76,15 @@
                     monotonic_clock::time_point monotonic_timestamp_time =
                         monotonic_clock::min_time);
 
-  // Coppies a message with the provided boot UUID.
-  void CopyDataMessage(DataEncoder::Copier *copier,
-                       const UUID &source_node_boot_uuid,
-                       aos::monotonic_clock::time_point now,
-                       aos::monotonic_clock::time_point message_time);
+  // Copies a message with the provided boot UUID.
+  // Similar to CopyMessage, but also checks that StoredDataType::DATA is
+  // allowed on this writer. Returns the duration of time spent on encoding the
+  // message.
+  std::chrono::nanoseconds CopyDataMessage(
+      DataEncoder::Copier *copier, const UUID &source_node_boot_uuid,
+      aos::monotonic_clock::time_point now,
+      aos::monotonic_clock::time_point message_time);
+
   void CopyTimestampMessage(DataEncoder::Copier *copier,
                             const UUID &source_node_boot_uuid,
                             aos::monotonic_clock::time_point now,
@@ -165,10 +169,12 @@
   // Signals that a node has rebooted.
   void Reboot(const UUID &source_node_boot_uuid);
 
-  void CopyMessage(DataEncoder::Copier *copier,
-                   const UUID &source_node_boot_uuid,
-                   aos::monotonic_clock::time_point now,
-                   aos::monotonic_clock::time_point message_time);
+  // Copies a message with the provided boot UUID.
+  // Returns the duration of time spent on encoding the message.
+  std::chrono::nanoseconds CopyMessage(
+      DataEncoder::Copier *copier, const UUID &source_node_boot_uuid,
+      aos::monotonic_clock::time_point now,
+      aos::monotonic_clock::time_point message_time);
 
   void QueueHeader(
       aos::SizePrefixedFlatbufferDetachedBuffer<LogFileHeader> &&header);
@@ -507,6 +513,16 @@
         });
   }
 
+  std::chrono::nanoseconds total_encode_duration() const {
+    return accumulate_data_writers(
+        total_encode_duration_,
+        [](std::chrono::nanoseconds x, const NewDataWriter &data_writer) {
+          CHECK_NOTNULL(data_writer.writer);
+          return x +
+                 data_writer.writer->WriteStatistics()->total_encode_duration();
+        });
+  }
+
   void ResetStatistics();
 
  protected:
@@ -575,6 +591,8 @@
   int max_write_time_bytes_ = -1;
   int max_write_time_messages_ = -1;
   std::chrono::nanoseconds total_write_time_ = std::chrono::nanoseconds::zero();
+  std::chrono::nanoseconds total_encode_duration_ =
+      std::chrono::nanoseconds::zero();
   int total_write_count_ = 0;
   int total_write_messages_ = 0;
   int total_write_bytes_ = 0;
diff --git a/aos/events/logging/log_writer.cc b/aos/events/logging/log_writer.cc
index c960ab9..ae43851 100644
--- a/aos/events/logging/log_writer.cc
+++ b/aos/events/logging/log_writer.cc
@@ -6,6 +6,9 @@
 #include <map>
 #include <vector>
 
+#include "absl/strings/ascii.h"  // for AsciiStrToLower
+#include "absl/strings/str_cat.h"
+
 #include "aos/configuration.h"
 #include "aos/events/event_loop.h"
 #include "aos/network/message_bridge_server_generated.h"
@@ -713,23 +716,29 @@
             ? f.fetcher->context().source_boot_uuid
             : event_loop_->boot_uuid();
     // Write!
-    const auto start = event_loop_->monotonic_now();
+    const monotonic_clock::time_point start_time = event_loop_->monotonic_now();
 
     ContextDataCopier coppier(f.fetcher->context(), f.logged_channel_index,
                               f.log_type, event_loop_);
 
-    aos::monotonic_clock::time_point message_time =
+    const aos::monotonic_clock::time_point message_time =
         static_cast<int>(node_index_) != f.data_node_index
             ? f.fetcher->context().monotonic_remote_time
             : f.fetcher->context().monotonic_event_time;
-    writer->CopyDataMessage(&coppier, source_node_boot_uuid, start,
-                            message_time);
-    RecordCreateMessageTime(start, coppier.end_time(), f);
+    const std::chrono::nanoseconds encode_duration = writer->CopyDataMessage(
+        &coppier, source_node_boot_uuid, start_time, message_time);
+    RecordCreateMessageTime(start_time, coppier.end_time(), f);
+
+    const Channel *channel = f.fetcher->channel();
 
     VLOG(2) << "Wrote data as node " << FlatbufferToJson(node_)
-            << " for channel "
-            << configuration::CleanedChannelToString(f.fetcher->channel())
+            << " for channel " << configuration::CleanedChannelToString(channel)
             << " to " << writer->name();
+
+    if (profiling_info_.has_value()) {
+      profiling_info_->WriteProfileData(message_time, start_time,
+                                        encode_duration, *channel);
+    }
   }
 }
 
@@ -938,4 +947,66 @@
   }
 }
 
+void Logger::SetProfilingPath(
+    const std::optional<std::filesystem::path> &path) {
+  if (path.has_value()) {
+    profiling_info_.emplace(path.value());
+
+  } else {
+    profiling_info_.reset();
+  }
+}
+
+void ProfileDataWriter::WriteProfileData(
+    const aos::monotonic_clock::time_point message_time,
+    const aos::monotonic_clock::time_point encoding_start_time,
+    const std::chrono::nanoseconds encode_duration, const Channel &channel) {
+  const int64_t encode_duration_ns =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(encode_duration)
+          .count();
+  const int64_t encoding_start_time_ns =
+      encoding_start_time.time_since_epoch().count();
+  const std::string message_time_s =
+      std::to_string(std::chrono::duration_cast<std::chrono::duration<double>>(
+                         message_time.time_since_epoch())
+                         .count());
+
+  const std::string log_entry =
+      absl::StrCat(channel.name()->string_view(), ",",  // channel name
+                   channel.type()->string_view(), ",",  // channel type
+                   encode_duration_ns, ",",             // encode duration
+                   encoding_start_time_ns, ",",         // encoding start time
+                   message_time_s, "\n"                 // message time
+      );
+  stream_ << log_entry;
+}
+
+ProfileDataWriter::ProfileDataWriter(const std::filesystem::path &path) {
+  CHECK(!path.empty());
+
+  const std::string extension = path.extension().string();
+  const std::string lower_case_extension = absl::AsciiStrToLower(extension);
+
+  // Warn if the path is not a csv file.
+  if (std::filesystem::is_directory(path)) {
+    LOG(WARNING) << "Path for logger profiling output file should be a csv "
+                    "file, not a directory. Received path: "
+                 << path << ".";
+  } else if (lower_case_extension != ".csv") {
+    LOG(WARNING) << "The extension for logger profiling output file should be "
+                    "'.csv'. Received path: "
+                 << extension << ".";
+  }
+
+  stream_.open(path, std::ios::out);
+  CHECK(stream_.is_open()) << ": Failed to open " << path;
+
+  // Write the header that describes the file content and the column names.
+  stream_
+      << "# This file is in csv format and contains profiling data for each "
+         "channel. The column names are: channel_name, channel_type, "
+         "encode_duration_ns, encoding_start_time_ns, message_time_s"
+      << std::endl;
+}
+
 }  // namespace aos::logger
diff --git a/aos/events/logging/log_writer.h b/aos/events/logging/log_writer.h
index 6091d7e..486ed8f 100644
--- a/aos/events/logging/log_writer.h
+++ b/aos/events/logging/log_writer.h
@@ -2,6 +2,7 @@
 #define AOS_EVENTS_LOGGING_LOG_WRITER_H_
 
 #include <chrono>
+#include <fstream>
 #include <string_view>
 #include <vector>
 
@@ -24,6 +25,31 @@
 aos::SizePrefixedFlatbufferDetachedBuffer<LogFileHeader> PackConfiguration(
     const Configuration *const configuration);
 
+// A class to manage the writing of profile data. It will open a file during
+// construction and close it when it goes out of scope.
+class ProfileDataWriter {
+ public:
+  // A constructor to open the stream.
+  ProfileDataWriter(const std::filesystem::path &csv_path);
+
+  // Write the profile data to the file as a csv line.
+  void WriteProfileData(
+      const aos::monotonic_clock::time_point message_time,
+      const aos::monotonic_clock::time_point encoding_start_time,
+      const std::chrono::nanoseconds encode_duration, const Channel &channel);
+
+  // A destructor to close the stream if it's open.
+  ~ProfileDataWriter() {
+    if (stream_.is_open()) {
+      stream_.close();
+    }
+  }
+
+ private:
+  // The stream to write profiling data to.
+  std::ofstream stream_;
+};
+
 // Logs all channels available in the event loop to disk every 100 ms.
 // Start by logging one message per channel to capture any state and
 // configuration that is sent rately on a channel and would affect execution.
@@ -88,6 +114,9 @@
   }
   std::chrono::nanoseconds polling_period() const { return polling_period_; }
 
+  // Sets the path to write profiling data to. nullopt will disable profiling.
+  void SetProfilingPath(const std::optional<std::filesystem::path> &path);
+
   std::optional<UUID> log_start_uuid() const { return log_start_uuid_; }
   UUID logger_instance_uuid() const { return logger_instance_uuid_; }
 
@@ -304,6 +333,12 @@
                                aos::monotonic_clock::time_point end,
                                const FetcherStruct &fetcher);
 
+  // Write an entry to the profile file.
+  void RecordProfileData(aos::monotonic_clock::time_point message_time,
+                         aos::monotonic_clock::time_point encoding_start_time,
+                         std::chrono::nanoseconds encode_duration,
+                         const Channel &channel);
+
   EventLoop *const event_loop_;
   // The configuration to place at the top of the log file.
   const Configuration *const configuration_;
@@ -384,6 +419,9 @@
 
   // Amount of time to run the logger behind now.
   std::chrono::nanoseconds logging_delay_ = std::chrono::nanoseconds(0);
+
+  // Profiling info
+  std::optional<ProfileDataWriter> profiling_info_;
 };
 
 }  // namespace aos::logger
diff --git a/aos/events/logging/logfile_utils.cc b/aos/events/logging/logfile_utils.cc
index 0676577..c01026f 100644
--- a/aos/events/logging/logfile_utils.cc
+++ b/aos/events/logging/logfile_utils.cc
@@ -172,23 +172,30 @@
   return *this;
 }
 
-void DetachedBufferWriter::CopyMessage(DataEncoder::Copier *copier,
-                                       aos::monotonic_clock::time_point now) {
+std::chrono::nanoseconds DetachedBufferWriter::CopyMessage(
+    DataEncoder::Copier *copier, aos::monotonic_clock::time_point now) {
   if (ran_out_of_space_) {
     // We don't want any later data to be written after space becomes
     // available, so refuse to write anything more once we've dropped data
     // because we ran out of space.
-    return;
+    return std::chrono::nanoseconds::zero();
   }
 
   const size_t message_size = copier->size();
   size_t overall_bytes_written = 0;
 
+  std::chrono::nanoseconds total_encode_duration =
+      std::chrono::nanoseconds::zero();
+
   // Keep writing chunks until we've written it all.  If we end up with a
   // partial write, this means we need to flush to disk.
   do {
+    // Initialize encode_duration for the case that the encoder cannot measure
+    // encode duration for a single message.
+    std::chrono::nanoseconds encode_duration = std::chrono::nanoseconds::zero();
     const size_t bytes_written =
-        encoder_->Encode(copier, overall_bytes_written);
+        encoder_->Encode(copier, overall_bytes_written, &encode_duration);
+
     CHECK(bytes_written != 0);
 
     overall_bytes_written += bytes_written;
@@ -197,16 +204,24 @@
               << message_size << " wrote " << overall_bytes_written;
       Flush(now);
     }
+    total_encode_duration += encode_duration;
   } while (overall_bytes_written < message_size);
 
+  WriteStatistics()->UpdateEncodeDuration(total_encode_duration);
+
   FlushAtThreshold(now);
+  return total_encode_duration;
 }
 
 void DetachedBufferWriter::Close() {
   if (!log_sink_->is_open()) {
     return;
   }
-  encoder_->Finish();
+  // Initialize encode_duration for the case that the encoder cannot measure
+  // encode duration for a single message.
+  std::chrono::nanoseconds encode_duration = std::chrono::nanoseconds::zero();
+  encoder_->Finish(&encode_duration);
+  WriteStats().UpdateEncodeDuration(encode_duration);
   while (encoder_->queue_size() > 0) {
     Flush(monotonic_clock::max_time);
   }
diff --git a/aos/events/logging/logfile_utils.h b/aos/events/logging/logfile_utils.h
index d781a20..f9a62b1 100644
--- a/aos/events/logging/logfile_utils.h
+++ b/aos/events/logging/logfile_utils.h
@@ -73,8 +73,9 @@
   // Triggers a flush if there's enough data queued up.
   //
   // Steals the detached buffer from it.
-  void CopyMessage(DataEncoder::Copier *coppier,
-                   aos::monotonic_clock::time_point now);
+  // Returns the duration of time spent on encoding the message.
+  std::chrono::nanoseconds CopyMessage(DataEncoder::Copier *copier,
+                                       aos::monotonic_clock::time_point now);
 
   // Indicates we got ENOSPC when trying to write. After this returns true, no
   // further data is written.
diff --git a/aos/events/logging/logger_test.cc b/aos/events/logging/logger_test.cc
index 7799c57..ea5071e 100644
--- a/aos/events/logging/logger_test.cc
+++ b/aos/events/logging/logger_test.cc
@@ -571,4 +571,129 @@
   EXPECT_EQ(replay_count, sent_messages);
 }
 
+// Helper function to verify the contents of the profiling data file.
+void VerifyProfilingData(const std::filesystem::path &profiling_path) {
+  std::ifstream file(profiling_path);
+  ASSERT_TRUE(file.is_open()) << "Failed to open profiling data file.";
+
+  std::string line;
+
+  // Verify that the header is a comment starting with '#'.
+  std::getline(file, line);
+  ASSERT_THAT(line, ::testing::StartsWith("#"));
+
+  // Now, verify the contents of each line.
+  int record_count = 0;
+
+  // Track the total encoding duration.
+  uint64_t total_encoding_duration_ns = 0;
+
+  while (std::getline(file, line)) {
+    std::stringstream line_stream(line);
+    std::string cell;
+
+    // Extract each cell from the CSV line.
+    std::vector<std::string> cells;
+    while (std::getline(line_stream, cell, ',')) {
+      cells.push_back(cell);
+    }
+
+    // Expecting 5 fields: channel_name, channel_type, encode_duration_ns,
+    // encoding_start_time_ns, message_time_s.
+    ASSERT_EQ(cells.size(), 5) << "Incorrect number of fields in the CSV line.";
+
+    // Channel name and type are strings and just need to not be empty.
+    EXPECT_FALSE(cells[0].empty()) << "Channel name is empty.";
+    EXPECT_FALSE(cells[1].empty()) << "Channel type is empty.";
+
+    // Encode duration, encoding start time should be positive numbers.
+    const int64_t encode_duration_ns = std::stoll(cells[2]);
+    const int64_t encoding_start_time_ns = std::stoll(cells[3]);
+
+    ASSERT_GT(encode_duration_ns, 0)
+        << "Encode duration is not positive. Line: " << line;
+    ASSERT_GT(encoding_start_time_ns, 0)
+        << "Encoding start time is not positive. Line: " << line;
+
+    // Message time should be non-negative.
+    const double message_time_s = std::stod(cells[4]);
+    EXPECT_GE(message_time_s, 0) << "Message time is negative";
+    ++record_count;
+    total_encoding_duration_ns += encode_duration_ns;
+  }
+
+  EXPECT_GT(record_count, 0) << "Profiling data file is empty.";
+  LOG(INFO) << "Total encoding duration: " << total_encoding_duration_ns;
+}
+
+// Tests logging many messages with LZMA compression.
+TEST_F(LoggerTest, ManyMessagesLzmaWithProfiling) {
+  const std::string tmpdir = aos::testing::TestTmpDir();
+  const std::string base_name = tmpdir + "/lzma_logfile";
+  const std::string config_sha256 =
+      absl::StrCat(base_name, kSingleConfigSha256, ".bfbs");
+  const std::string logfile = absl::StrCat(base_name, ".part0.xz");
+  const std::string profiling_path =
+      absl::StrCat(tmpdir, "/encoding_profile.csv");
+
+  // Clean up any previous test artifacts.
+  unlink(config_sha256.c_str());
+  unlink(logfile.c_str());
+
+  LOG(INFO) << "Logging data to " << logfile;
+  ping_.set_quiet(true);
+
+  {
+    std::unique_ptr<aos::EventLoop> logger_event_loop =
+        event_loop_factory_.MakeEventLoop("logger");
+
+    std::unique_ptr<aos::EventLoop> ping_spammer_event_loop =
+        event_loop_factory_.MakeEventLoop("ping_spammer");
+    aos::Sender<examples::Ping> ping_sender =
+        ping_spammer_event_loop->MakeSender<examples::Ping>("/test");
+
+    aos::TimerHandler *timer_handler =
+        ping_spammer_event_loop->AddTimer([&ping_sender]() {
+          aos::Sender<examples::Ping>::Builder builder =
+              ping_sender.MakeBuilder();
+          examples::Ping::Builder ping_builder =
+              builder.MakeBuilder<examples::Ping>();
+          CHECK_EQ(builder.Send(ping_builder.Finish()),
+                   aos::RawSender::Error::kOk);
+        });
+
+    // Send a message every 50 microseconds to simulate high throughput.
+    ping_spammer_event_loop->OnRun([&ping_spammer_event_loop, timer_handler]() {
+      timer_handler->Schedule(ping_spammer_event_loop->monotonic_now(),
+                              std::chrono::microseconds(50));
+    });
+
+    aos::logger::Logger logger(logger_event_loop.get());
+    logger.set_separate_config(false);
+    logger.set_polling_period(std::chrono::milliseconds(100));
+
+    // Enable logger profiling.
+    logger.SetProfilingPath(profiling_path);
+
+    std::unique_ptr<aos::logger::MultiNodeFilesLogNamer> log_namer =
+        std::make_unique<aos::logger::MultiNodeFilesLogNamer>(
+            base_name, logger_event_loop->configuration(),
+            logger_event_loop.get(), logger_event_loop->node());
+#ifdef LZMA
+    // Set up LZMA encoder.
+    log_namer->set_encoder_factory([](size_t max_message_size) {
+      return std::make_unique<aos::logger::LzmaEncoder>(max_message_size, 1);
+    });
+#endif
+
+    logger.StartLogging(std::move(log_namer));
+
+    event_loop_factory_.RunFor(std::chrono::seconds(1));
+  }
+
+#ifdef LZMA
+  VerifyProfilingData(profiling_path);
+#endif
+}
+
 }  // namespace aos::logger::testing
diff --git a/aos/events/logging/lzma_encoder.cc b/aos/events/logging/lzma_encoder.cc
index 27d01ab..a757560 100644
--- a/aos/events/logging/lzma_encoder.cc
+++ b/aos/events/logging/lzma_encoder.cc
@@ -95,7 +95,8 @@
 
 LzmaEncoder::~LzmaEncoder() { lzma_end(&stream_); }
 
-size_t LzmaEncoder::Encode(Copier *copy, size_t start_byte) {
+size_t LzmaEncoder::Encode(Copier *copy, size_t start_byte,
+                           std::chrono::nanoseconds *encode_duration) {
   const size_t copy_size = copy->size();
   // LZMA compresses the data as it goes along, copying the compressed results
   // into another buffer.  So, there's no need to store more than one message
@@ -107,13 +108,14 @@
 
   stream_.next_in = input_buffer_.data();
   stream_.avail_in = copy_size;
-
-  RunLzmaCode(LZMA_RUN);
+  RunLzmaCode(LZMA_RUN, encode_duration);
 
   return copy_size - start_byte;
 }
 
-void LzmaEncoder::Finish() { RunLzmaCode(LZMA_FINISH); }
+void LzmaEncoder::Finish(std::chrono::nanoseconds *encode_duration) {
+  RunLzmaCode(LZMA_FINISH, encode_duration);
+}
 
 void LzmaEncoder::Clear(const int n) {
   CHECK_GE(n, 0);
@@ -154,7 +156,8 @@
   return bytes;
 }
 
-void LzmaEncoder::RunLzmaCode(lzma_action action) {
+void LzmaEncoder::RunLzmaCode(lzma_action action,
+                              std::chrono::nanoseconds *encode_duration) {
   CHECK(!finished_);
 
   // This is to keep track of how many bytes resulted from encoding this input
@@ -181,8 +184,20 @@
       last_avail_out = stream_.avail_out;
     }
 
-    // Encode the data.
-    lzma_ret status = lzma_code(&stream_, action);
+    // Declare status, which will be populated by lzma_code.
+    lzma_ret status;
+
+    if (encode_duration == nullptr) {
+      // Perform lzma_code without measuring the time.
+      status = lzma_code(&stream_, action);
+    } else {
+      // Measure the encoding time of lzma_code
+      const monotonic_clock::time_point start_time =
+          aos::monotonic_clock::now();
+      status = lzma_code(&stream_, action);
+      *encode_duration = aos::monotonic_clock::now() - start_time;
+    }
+
     CHECK(LzmaCodeIsOk(status));
     if (action == LZMA_FINISH) {
       if (status == LZMA_STREAM_END) {
diff --git a/aos/events/logging/lzma_encoder.h b/aos/events/logging/lzma_encoder.h
index 93508ca..d0d9280 100644
--- a/aos/events/logging/lzma_encoder.h
+++ b/aos/events/logging/lzma_encoder.h
@@ -39,18 +39,23 @@
     return true;
   }
   size_t space() const final { return input_buffer_.capacity(); }
-  size_t Encode(Copier *copy, size_t start_byte) final;
-  void Finish() final;
+
+  // See base class for commments.
+  size_t Encode(Copier *copy, size_t start_byte,
+                std::chrono::nanoseconds *encode_duration = nullptr) final;
+  void Finish(std::chrono::nanoseconds *encode_duration = nullptr) final;
   void Clear(int n) final;
   absl::Span<const absl::Span<const uint8_t>> queue() final;
   size_t queued_bytes() const final;
   size_t total_bytes() const final { return total_bytes_; }
+
   size_t queue_size() const final { return queue_.size(); }
 
  private:
   static constexpr size_t kEncodedBufferSizeBytes{1024 * 128};
 
-  void RunLzmaCode(lzma_action action);
+  void RunLzmaCode(lzma_action action,
+                   std::chrono::nanoseconds *encode_duration);
 
   lzma_stream stream_;
   uint32_t compression_preset_;
@@ -65,6 +70,9 @@
   // Reset.
   size_t total_bytes_ = 0;
 
+  std::chrono::nanoseconds total_encode_duration_ =
+      std::chrono::nanoseconds::zero();
+
   // Buffer that messages get coppied into for encoding.
   ResizeableBuffer input_buffer_;
 
diff --git a/aos/events/logging/plot_logger_profile.py b/aos/events/logging/plot_logger_profile.py
new file mode 100644
index 0000000..125b308
--- /dev/null
+++ b/aos/events/logging/plot_logger_profile.py
@@ -0,0 +1,287 @@
+# Parse log profiling data and produce a graph showing encode times in time bins,
+# with a breakdown per message type.
+
+import argparse
+import csv
+import math
+import os
+import webbrowser
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+from bokeh.io import output_notebook
+from bokeh.models import ColumnDataSource, HoverTool, Legend, LegendItem
+from bokeh.palettes import Category20, Viridis256
+from bokeh.plotting import figure, show, output_file
+from tabulate import tabulate
+
+
+@dataclass
+class SeriesDetail:
+    event_loop_times_s: List[float]
+    encode_times_ms: List[float]
+
+
+def parse_csv_file(filepath: Path, max_lines: Optional[int],
+                   start_time: Optional[float],
+                   end_time: Optional[float]) -> Dict[str, SeriesDetail]:
+    """Parses the CSV file to extract needed data, respecting the maximum number of lines if provided."""
+    data_by_type: Dict[str, SeriesDetail] = {}
+
+    with open(filepath, 'r') as file:
+        reader = csv.reader(file)
+        next(reader)  # Skip the header line
+
+        line_count = 0
+        for line in reader:
+            if max_lines is not None and line_count >= max_lines:
+                break
+
+            line_count += 1
+
+            assert len(line) > 0
+
+            # Note that channel_name and encoding_start_time_ns are not yet used.
+            # They may be used here in the future, but for now they are helpful when
+            # directly looking at the csv file.
+            channel_name, channel_type, encode_duration_ns, encoding_start_time_ns, message_time_s = line
+
+            # Convert nanoseconds to milliseconds
+            encode_duration_ms = float(encode_duration_ns) * 1e-6
+            message_time_s = float(message_time_s)
+
+            if (start_time is not None and message_time_s < start_time):
+                continue
+            if (end_time is not None and message_time_s > end_time):
+                continue
+
+            if channel_type in data_by_type:
+                data_by_type[channel_type].encode_times_ms.append(
+                    encode_duration_ms)
+                data_by_type[channel_type].event_loop_times_s.append(
+                    message_time_s)
+            else:
+                data_by_type[channel_type] = SeriesDetail(
+                    encode_times_ms=[encode_duration_ms],
+                    event_loop_times_s=[message_time_s])
+
+    return data_by_type
+
+
+@dataclass
+class DataBin:
+    bin_range: str
+    message_encode_times: Dict[str, float]
+
+
+@dataclass
+class BinnedData:
+    bins: List[DataBin] = field(default_factory=list)
+    top_type_names: List[str] = field(default_factory=list)
+
+
+def create_binned_data(data_by_type: Dict[str, SeriesDetail],
+                       num_bins: int = 25,
+                       top_n: int = 5) -> BinnedData:
+    # Calculate total encoding times for each message type across the entire file.
+    total_encode_times: Dict[str, float] = {
+        message_type: sum(detail.encode_times_ms)
+        for message_type, detail in data_by_type.items()
+    }
+
+    # Determine the top N message types based on total encoding times.
+    top_types: List[Tuple[str, float]] = sorted(total_encode_times.items(),
+                                                key=lambda item: item[1],
+                                                reverse=True)[:top_n]
+    print(f"{top_types=}")
+    top_type_names: List[str] = [type_name for type_name, _ in top_types]
+
+    # Find the global minimum and maximum times to establish bin edges.
+    min_time: float = min(detail.event_loop_times_s[0]
+                          for detail in data_by_type.values())
+    max_time: float = max(detail.event_loop_times_s[-1]
+                          for detail in data_by_type.values())
+
+    # Create bins.
+    bins = np.linspace(min_time, max_time, num_bins + 1)
+
+    # Initialize the list of DataBin instances with the correct number of bins.
+    binned_data = BinnedData(top_type_names=top_type_names)
+    for i in range(num_bins):
+        bin_range = f"{bins[i]:.2f} - {bins[i+1]:.2f}"
+        binned_data.bins.append(
+            DataBin(bin_range=bin_range,
+                    message_encode_times={
+                        name: 0
+                        for name in top_type_names + ['other']
+                    }))
+
+    # Populate binned_data with message encode times.
+    for message_type, details in data_by_type.items():
+        binned_indices = np.digitize(details.event_loop_times_s, bins) - 1
+        # Correcting the bin indices that are out of range by being exactly on the maximum edge.
+        binned_indices = np.minimum(binned_indices, num_bins - 1)
+
+        for idx, encode_time in enumerate(details.encode_times_ms):
+            bin_index = binned_indices[idx]
+            current_bin = binned_data.bins[bin_index]
+            if message_type in top_type_names:
+                current_bin.message_encode_times[message_type] += encode_time
+            else:
+                current_bin.message_encode_times['other'] += encode_time
+
+    return binned_data
+
+
+def print_binned_data(binned_data: BinnedData) -> None:
+    # Extend headers for the table by replacing '.' with '\n.' for each message type name and
+    # adding 'Total'.
+    headers = ['Bin Range'] + [
+        key.replace('.', '\n.')
+        for key in binned_data.top_type_names + ['other']
+    ] + ['Total']
+
+    # Initialize the table data list.
+    table_data = []
+
+    # Populate the table data with the values from each DataBin instance and calculate totals.
+    for data_bin in binned_data.bins:
+        # Initialize a row with the bin range.
+        row = [data_bin.bin_range]
+        # Add the total message encode times for each message type.
+        encode_times = [
+            data_bin.message_encode_times[message_type]
+            for message_type in binned_data.top_type_names
+        ]
+        other_time = data_bin.message_encode_times['other']
+        row += encode_times + [other_time]
+        # Calculate the total encode time for the row and append it.
+        total_encode_time = sum(encode_times) + other_time
+        row.append(total_encode_time)
+        # Append the row to the table data.
+        table_data.append(row)
+
+    # Print the table using tabulate with 'grid' format for better structure.
+    print(
+        tabulate(table_data, headers=headers, tablefmt='grid', floatfmt=".2f"))
+
+
+def plot_bar(binned_data: BinnedData) -> None:
+    filename = "plot.html"
+    output_file(filename, title="Message Encode Time Plot Stacked Bar Graph")
+
+    # Adjust width based on bin count for readability.
+    plot_width = max(1200, 50 * len(binned_data.bins))
+
+    p = figure(x_range=[bin.bin_range for bin in binned_data.bins],
+               title='Message Encode Time by Type over Event Loop Time',
+               x_axis_label='Event Loop Time Bins',
+               y_axis_label='Total Message Encode Time (ms)',
+               width=plot_width,
+               height=600,
+               tools="")
+
+    source_data = {'bin_edges': [bin.bin_range for bin in binned_data.bins]}
+    for message_type in binned_data.top_type_names + ['other']:
+        source_data[message_type] = [
+            bin.message_encode_times.get(message_type, 0)
+            for bin in binned_data.bins
+        ]
+
+    source = ColumnDataSource(data=source_data)
+
+    # Calculate totals and sort in descending order.
+    totals = {
+        message_type: sum(source_data[message_type])
+        for message_type in source_data if message_type != 'bin_edges'
+    }
+    sorted_message_types = sorted(totals, key=totals.get, reverse=True)
+
+    # Reverse the list to place larger segments at the top.
+    sorted_message_types.reverse()
+
+    num_types = len(sorted_message_types)
+    if num_types > 20:
+        raise ValueError(
+            f"Number of types ({num_types}) exceeds the number of available colors in Category20."
+        )
+    colors = Category20[20][:num_types]
+
+    # Apply reversed order to stack rendering.
+    renderers = p.vbar_stack(sorted_message_types,
+                             x='bin_edges',
+                             width=0.7,
+                             color=colors,
+                             source=source)
+
+    # Change the orientation of the x-axis labels to a 45-degree angle.
+    p.xaxis.major_label_orientation = math.pi / 4
+
+    # Create a custom legend, maintaining the reversed order for visual consistency.
+    legend_items = [
+        LegendItem(label=mt.replace('.', ' '), renderers=[renderers[i]])
+        for i, mt in enumerate(sorted_message_types)
+    ]
+    legend = Legend(items=legend_items, location=(0, -30))
+    p.add_layout(legend, 'right')
+
+    p.y_range.start = 0
+    p.x_range.range_padding = 0.05
+    p.xgrid.grid_line_color = None
+    p.axis.minor_tick_line_color = None
+    p.outline_line_color = None
+
+    file_path = os.path.realpath(filename)
+    print('\n')
+    print(f"Plot saved to '{file_path}'")
+    webbrowser.open('file://' + file_path)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=
+        'Process log files to extract and plot message encode times.')
+    parser.add_argument('--log_file_path',
+                        type=Path,
+                        help='Path to the log file',
+                        required=True)
+    parser.add_argument(
+        '--max_lines',
+        type=int,
+        default=None,
+        help='Maximum number of lines to read from the log file')
+    parser.add_argument('--num_bins',
+                        type=int,
+                        default=40,
+                        help='Number of bins to use')
+    parser.add_argument('--top_n',
+                        type=int,
+                        default=10,
+                        help='Number of top message types to plot')
+    parser.add_argument('--start_time',
+                        type=float,
+                        default=None,
+                        help='Start time in seconds')
+    parser.add_argument('--end_time',
+                        type=float,
+                        default=None,
+                        help='End time in seconds')
+
+    args = parser.parse_args()
+
+    data_by_type = parse_csv_file(filepath=args.log_file_path,
+                                  max_lines=args.max_lines,
+                                  start_time=args.start_time,
+                                  end_time=args.end_time)
+    binned_data = create_binned_data(data_by_type,
+                                     num_bins=args.num_bins,
+                                     top_n=args.top_n)
+    print_binned_data(binned_data)
+    plot_bar(binned_data)
+    print(f"{os.path.basename(__file__)} Finished.")
+
+
+if __name__ == '__main__':
+    main()
diff --git a/aos/events/logging/plot_logger_profile_test.py b/aos/events/logging/plot_logger_profile_test.py
new file mode 100644
index 0000000..b3e7c70
--- /dev/null
+++ b/aos/events/logging/plot_logger_profile_test.py
@@ -0,0 +1,109 @@
+import unittest
+from unittest.mock import mock_open, patch
+from pathlib import Path
+import numpy as np
+from aos.events.logging.plot_logger_profile import SeriesDetail, parse_csv_file, create_binned_data
+
+# Mock CSV data as a string
+# The actual column names are "channel_name, channel_type, encode_duration_ns, encoding_start_time_ns, message_time_s".
+mock_csv = """# It doesn't matter what's in this comment. The column names are put here for your reference.
+/test/channel/name1,aos.test.channel.name1,1000000,123456789,10
+/test/channel/name2,aos.test.channel.name1,2000000,123456789,20
+/test/channel/name3,aos.test.channel.name2,3000000,123456789,30
+"""
+
+
+class TestLogParser(unittest.TestCase):
+
+    def test_parse_csv_file(self):
+        # Expected result after parsing the mock CSV, using SeriesDetail instances
+        expected_result = {
+            'aos.test.channel.name1':
+            SeriesDetail(encode_times_ms=[1.0, 2.0],
+                         event_loop_times_s=[10.0, 20.0]),
+            'aos.test.channel.name2':
+            SeriesDetail(encode_times_ms=[3.0], event_loop_times_s=[30.0])
+        }
+
+        # Use 'mock_open' to simulate file opening and reading
+        with patch('builtins.open', mock_open(read_data=mock_csv)):
+            # Parse the data assuming the mock file path is 'dummy_path.csv'
+            result = parse_csv_file(Path('dummy_path.csv'),
+                                    max_lines=None,
+                                    start_time=None,
+                                    end_time=None)
+
+            # Check if the parsed data matches the expected result
+            self.assertEqual(result, expected_result)
+
+
+class TestCreateBinnedData(unittest.TestCase):
+
+    def test_create_binned_data_with_other_category(self):
+        # Setup input data with three types
+        data_by_type = {
+            'Type1':
+            SeriesDetail(encode_times_ms=[10.0, 20.0, 30.0],
+                         event_loop_times_s=[13.0, 23.0, 33.0]),
+            'Type2':
+            SeriesDetail(encode_times_ms=[15.0, 25.0, 35.0],
+                         event_loop_times_s=[18.0, 28.0, 38.0]),
+            'Type3':
+            SeriesDetail(encode_times_ms=[5.0, 10.0, 15.0],
+                         event_loop_times_s=[8.0, 19.0, 29.0])
+        }
+
+        # Choose top_n less than the number of types. This will cause Type3's data to go into 'other'
+        top_n = 2
+
+        # Sort the types by total encoding times to determine top types
+        expected_top_types = ['Type2', 'Type1']
+
+        bins = np.linspace(8, 38, len(data_by_type) + 1)
+
+        # Expected output for 3 bins. The bin bounds were measured to be 18.0, 28.0, and 38.0.
+        expected_bins = [
+            {
+                "bin_range": f"{bins[0]:.2f} - {bins[1]:.2f}",
+                "message_encode_times": {
+                    "Type1": 10.0,
+                    "Type2": 0,
+                    "other": 5.0
+                }
+            },
+            {
+                "bin_range": f"{bins[1]:.2f} - {bins[2]:.2f}",
+                "message_encode_times": {
+                    "Type1": 20.0,
+                    "Type2": 15.0,
+                    "other": 10.0
+                }
+            },
+            {
+                "bin_range": f"{bins[2]:.2f} - {bins[3]:.2f}",
+                "message_encode_times": {
+                    "Type1": 30.0,
+                    "Type2": 60.0,
+                    "other": 15.0
+                }
+            },
+        ]
+
+        # Call the function under test
+        result = create_binned_data(data_by_type,
+                                    num_bins=3,
+                                    top_n=len(expected_top_types))
+
+        # Check the top type names and order
+        self.assertEqual(result.top_type_names, expected_top_types)
+
+        # Check each bin's range and encode times
+        for idx, bin_data in enumerate(result.bins):
+            self.assertEqual(bin_data.bin_range,
+                             expected_bins[idx]["bin_range"])
+            self.assertEqual(bin_data.message_encode_times,
+                             expected_bins[idx]["message_encode_times"])
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/aos/events/logging/snappy_encoder.cc b/aos/events/logging/snappy_encoder.cc
index 0e96092..0160177 100644
--- a/aos/events/logging/snappy_encoder.cc
+++ b/aos/events/logging/snappy_encoder.cc
@@ -41,9 +41,16 @@
   total_bytes_ += queue_.back().size();
 }
 
-void SnappyEncoder::Finish() { EncodeCurrentBuffer(); }
+void SnappyEncoder::Finish(std::chrono::nanoseconds * /*encode_duration*/) {
+  // TODO (Maxwell Gumley): find a way to measure encode duration for a single
+  // message.
+  EncodeCurrentBuffer();
+}
 
-size_t SnappyEncoder::Encode(Copier *copy, size_t start_byte) {
+size_t SnappyEncoder::Encode(Copier *copy, size_t start_byte,
+                             std::chrono::nanoseconds * /*encode_duration*/) {
+  // TODO (Maxwell Gumley): find a way to measure encode duration for a single
+  // message.
   CHECK_EQ(start_byte, 0u);
   buffer_source_.Append(copy);
 
diff --git a/aos/events/logging/snappy_encoder.h b/aos/events/logging/snappy_encoder.h
index 4b6130c..76100e3 100644
--- a/aos/events/logging/snappy_encoder.h
+++ b/aos/events/logging/snappy_encoder.h
@@ -20,9 +20,11 @@
   explicit SnappyEncoder(size_t max_message_size,
                          size_t chunk_size = 128 * 1024);
 
-  size_t Encode(Copier *copy, size_t start_byte) final;
+  // See base class for commments.
+  size_t Encode(Copier *copy, size_t start_byte,
+                std::chrono::nanoseconds *encode_duration = nullptr) final;
 
-  void Finish() final;
+  void Finish(std::chrono::nanoseconds *encode_duration = nullptr) final;
   void Clear(int n) final;
   absl::Span<const absl::Span<const uint8_t>> queue() final;
   size_t queued_bytes() const final;