diff --git a/aeron-client/src/main/cpp_wrapper/CMakeLists.txt b/aeron-client/src/main/cpp_wrapper/CMakeLists.txt
index af6d23af79..5d8df201d7 100644
--- a/aeron-client/src/main/cpp_wrapper/CMakeLists.txt
+++ b/aeron-client/src/main/cpp_wrapper/CMakeLists.txt
@@ -52,7 +52,6 @@ SET(HEADERS
     ${CMAKE_CURRENT_SOURCE_DIR}/concurrent/atomic/Atomic64_gcc_cpp11.h
     ${CMAKE_CURRENT_SOURCE_DIR}/concurrent/atomic/Atomic64_gcc_x86_64.h
     ${CMAKE_CURRENT_SOURCE_DIR}/concurrent/atomic/Atomic64_msvc.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/concurrent/errors/ErrorLogDescriptor.h
     ${CMAKE_CURRENT_SOURCE_DIR}/concurrent/errors/ErrorLogReader.h
     ${CMAKE_CURRENT_SOURCE_DIR}/concurrent/logbuffer/BufferClaim.h
     ${CMAKE_CURRENT_SOURCE_DIR}/concurrent/logbuffer/DataFrameHeader.h
diff --git a/aeron-client/src/main/cpp_wrapper/concurrent/errors/ErrorLogDescriptor.h b/aeron-client/src/main/cpp_wrapper/concurrent/errors/ErrorLogDescriptor.h
deleted file mode 100644
index 238b959b1f..0000000000
--- a/aeron-client/src/main/cpp_wrapper/concurrent/errors/ErrorLogDescriptor.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright 2014-2025 Real Logic Limited.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef AERON_CONCURRENT_ERROR_LOG_DESCRIPTOR_H
-#define AERON_CONCURRENT_ERROR_LOG_DESCRIPTOR_H
-
-#include <cstddef>
-
-#include "util/Index.h"
-
-namespace aeron { namespace concurrent { namespace errors {
-
-/**
- * Distinct record of error observations. Rather than grow a record indefinitely when many errors of the same type
- * are logged, this log takes the approach of only recording distinct errors of the same type type and stack trace
- * and keeping a count and time of observation so that the record only grows with new distinct observations.
- *
- * The provided {@link AtomicBuffer} can wrap a memory-mapped file so logging can be out of process. This provides
- * the benefit that if a crash or lockup occurs then the log can be read externally without loss of data.
- *
- * This class is threadsafe to be used from multiple logging threads.
- *
- * The error records are recorded to the memory mapped buffer in the following format.
- *
- * <pre>
- *   0                   1                   2                   3
- *   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
- *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
- *  |R|                         Length                              |
- *  +-+-------------------------------------------------------------+
- *  |R|                     Observation Count                       |
- *  +-+-------------------------------------------------------------+
- *  |R|                Last Observation Timestamp                   |
- *  |                                                               |
- *  +-+-------------------------------------------------------------+
- *  |R|               First Observation Timestamp                   |
- *  |                                                               |
- *  +---------------------------------------------------------------+
- *  |                     ASCII Encoded Error                      ...
- * ...                                                              |
- *  +---------------------------------------------------------------+
- * </pre>
- */
-
-namespace ErrorLogDescriptor {
-
-#pragma pack(push)
-#pragma pack(4)
-struct ErrorLogEntryDefn
-{
-    std::int32_t length;
-    std::int32_t observationCount;
-    std::int64_t lastObservationTimestamp;
-    std::int64_t firstObservationTimestamp;
-};
-#pragma pack(pop)
-
-static const util::index_t LENGTH_OFFSET = offsetof(ErrorLogEntryDefn, length);
-static const util::index_t OBSERVATION_COUNT_OFFSET = offsetof(ErrorLogEntryDefn, observationCount);
-static const util::index_t LAST_OBSERVATION_TIMESTAMP_OFFSET = offsetof(ErrorLogEntryDefn, lastObservationTimestamp);
-static const util::index_t FIRST_OBSERVATION_TIMESTAMP_OFFSET = offsetof(ErrorLogEntryDefn, firstObservationTimestamp);
-static const util::index_t ENCODED_ERROR_OFFSET = sizeof(ErrorLogEntryDefn);
-static const util::index_t HEADER_LENGTH = sizeof(ErrorLogEntryDefn);
-
-static const util::index_t RECORD_ALIGNMENT = sizeof(std::int64_t);
-
-}
-
-}}}
-
-#endif
diff --git a/aeron-client/src/main/cpp_wrapper/concurrent/errors/ErrorLogReader.h b/aeron-client/src/main/cpp_wrapper/concurrent/errors/ErrorLogReader.h
index ca417ce4c7..c3e4567ec0 100644
--- a/aeron-client/src/main/cpp_wrapper/concurrent/errors/ErrorLogReader.h
+++ b/aeron-client/src/main/cpp_wrapper/concurrent/errors/ErrorLogReader.h
@@ -17,9 +17,11 @@
 #define AERON_CONCURRENT_ERROR_LOG_READER_H
 
 #include <functional>
-#include "util/BitUtil.h"
 #include "concurrent/AtomicBuffer.h"
-#include "concurrent/errors/ErrorLogDescriptor.h"
+extern "C"
+{
+#include "concurrent/aeron_distinct_error_log.h"
+}
 
 namespace aeron { namespace concurrent { namespace errors {
 
@@ -35,40 +37,26 @@ typedef std::function<void(
 
 inline static int read(AtomicBuffer &buffer, const error_consumer_t &consumer, std::int64_t sinceTimestamp)
 {
-    int entries = 0;
-    int offset = 0;
-    const int capacity = buffer.capacity();
-
-    while (offset < capacity)
+    aeron_error_log_reader_func_t aeron_error_log_consumer = [](
+        int32_t observation_count,
+        int64_t first_observation_timestamp,
+        int64_t last_observation_timestamp,
+        const char *encoded_exception,
+        size_t length,
+        void *client_id)
     {
-        const std::int32_t length = buffer.getInt32Volatile(offset + ErrorLogDescriptor::LENGTH_OFFSET);
-        if (0 == length)
-        {
-            break;
-        }
-
-        const std::int64_t lastObservationTimestamp =
-            buffer.getInt64Volatile(offset + ErrorLogDescriptor::LAST_OBSERVATION_TIMESTAMP_OFFSET);
-
-        if (lastObservationTimestamp >= sinceTimestamp)
-        {
-            auto &entry = buffer.overlayStruct<ErrorLogDescriptor::ErrorLogEntryDefn>(offset);
-
-            ++entries;
-
-            consumer(
-                entry.observationCount,
-                entry.firstObservationTimestamp,
-                lastObservationTimestamp,
-                buffer.getStringWithoutLength(
-                    offset + ErrorLogDescriptor::ENCODED_ERROR_OFFSET,
-                    static_cast<std::size_t>(length - ErrorLogDescriptor::HEADER_LENGTH)));
-        }
-
-        offset += util::BitUtil::align(length, ErrorLogDescriptor::RECORD_ALIGNMENT);
-    }
-
-    return entries;
+        auto consumer = reinterpret_cast<error_consumer_t *>(client_id);
+        (*consumer)(observation_count,
+            first_observation_timestamp,
+            last_observation_timestamp,
+            std::string(encoded_exception, length));
+    };
+    return static_cast<int>(aeron_error_log_read(
+        buffer.buffer(),
+        buffer.capacity(),
+        aeron_error_log_consumer,
+        const_cast<void *>(reinterpret_cast<const void *>(&consumer)),
+        sinceTimestamp));
 }
 
 }}}}