apache-iggy 0.7.4.dev1__tar.gz → 0.7.5.dev1__tar.gz

{apache_iggy-0.7.4.dev1 → apache_iggy-0.7.5.dev1}/Cargo.toml

@@ -66,6 +66,7 @@ actix-files = "0.6.10"
 actix-web = "4.13.0"
 aes-gcm = "0.10.3"
 ahash = { version = "0.8.12", features = ["serde"] }
+aligned-vec = "0.6.4"
 anyhow = "1.0.102"
 argon2 = "0.5.3"
 arrow = "57.3.0"
@@ -134,7 +135,6 @@ dirs = "6.0.0"
 dlopen2 = "0.8.2"
 dotenvy = "0.15.7"
 elasticsearch = { version = "9.1.0-alpha.1", features = ["rustls-tls"], default-features = false }
-enum_dispatch = "0.3.13"
 enumset = "1.1"
 env_logger = "0.11.9"
 err_trail = { version = "0.11.0", features = ["tracing"] }
@@ -160,11 +160,11 @@ hwlocality = "1.0.0-alpha.11"
 iceberg = "0.9.0"
 iceberg-catalog-rest = "0.9.0"
 iceberg-storage-opendal = "0.9.0"
-iggy = { path = "core/sdk", version = "0.9.3-edge.1" }
-iggy-cli = { path = "core/cli", version = "0.11.3-edge.1" }
-iggy_binary_protocol = { path = "core/binary_protocol", version = "0.9.3-edge.1" }
-iggy_common = { path = "core/common", version = "0.9.3-edge.1" }
-iggy_connector_sdk = { path = "core/connectors/sdk", version = "0.2.1-edge.1" }
+iggy = { path = "core/sdk", version = "0.9.5-edge.1" }
+iggy-cli = { path = "core/cli", version = "0.12.1-edge.1" }
+iggy_binary_protocol = { path = "core/binary_protocol", version = "0.9.5-edge.1" }
+iggy_common = { path = "core/common", version = "0.9.5-edge.1" }
+iggy_connector_sdk = { path = "core/connectors/sdk", version = "0.2.2-edge.1" }
 integration = { path = "core/integration" }
 journal = { path = "core/journal" }
 js-sys = "0.3"
@@ -183,7 +183,7 @@ mime_guess = "2.0"
 mockall = "0.14.0"
 moka = { version = "0.12.14", features = ["future"] }
 mongodb = { version = "3.5.2", features = ["rustls-tls"] }
-nix = { version = "0.31.2", features = ["fs", "resource", "sched"] }
+nix = { version = "0.31.2", features = ["feature", "fs", "resource", "sched"] }
 nonzero_lit = "0.1.2"
 notify = "8.2.0"
 octocrab = "0.49.5"

{apache_iggy-0.7.4.dev1 → apache_iggy-0.7.5.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apache-iggy
-Version: 0.7.4.dev1
+Version: 0.7.5.dev1
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License

{apache_iggy-0.7.4.dev1 → apache_iggy-0.7.5.dev1}/core/common/Cargo.toml

@@ -16,7 +16,7 @@
 # under the License.
 [package]
 name = "iggy_common"
-version = "0.9.3-edge.1"
+version = "0.9.5-edge.1"
 description = "Iggy is the persistent message streaming platform written in Rust, supporting QUIC, TCP and HTTP transport protocols, capable of processing millions of messages per second."
 edition = "2024"
 license = "Apache-2.0"
@@ -30,13 +30,13 @@ readme = "README.md"
 [dependencies]
 aes-gcm = { workspace = true }
 ahash = { workspace = true }
+aligned-vec = { workspace = true }
 async-broadcast = { workspace = true }
 async-trait = { workspace = true }
 base64 = { workspace = true }
 blake3 = { workspace = true }
 bon = { workspace = true }
 byte-unit = { workspace = true }
-bytemuck = { workspace = true }
 bytes = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
@@ -44,7 +44,6 @@ comfy-table = { workspace = true }
 compio = { workspace = true }
 crossbeam = { workspace = true }
 derive_more = { workspace = true }
-enumset = { workspace = true }
 err_trail = { workspace = true }
 human-repr = { workspace = true }
 humantime = { workspace = true }

{apache_iggy-0.7.4.dev1 → apache_iggy-0.7.5.dev1}/core/common/src/alloc/buffer.rs

@@ -16,11 +16,15 @@
  * under the License.
  */
 
-use super::memory_pool::{BytesMutExt, memory_pool};
-use bytes::{Buf, BufMut, Bytes, BytesMut};
+use crate::alloc::memory_pool::{ALIGNMENT, AlignedBuffer};
+
+use super::memory_pool::{AlignedBufferExt, memory_pool};
+use bytes::Bytes;
 use compio::buf::{IoBuf, IoBufMut, SetLen};
-use std::mem::MaybeUninit;
-use std::ops::{Deref, DerefMut};
+use std::{
+    mem::MaybeUninit,
+    ops::{Deref, DerefMut},
+};
 
 /// A buffer wrapper that participates in memory pooling.
 ///
@@ -32,7 +36,7 @@ pub struct PooledBuffer {
     from_pool: bool,
     original_capacity: usize,
     original_bucket_idx: Option<usize>,
-    inner: BytesMut,
+    inner: AlignedBuffer,
 }
 
 impl Default for PooledBuffer {
@@ -48,13 +52,21 @@ impl PooledBuffer {
     ///
     /// * `capacity` - The capacity of the buffer
     pub fn with_capacity(capacity: usize) -> Self {
-        let (buffer, was_pool_allocated) = memory_pool().acquire_buffer(capacity);
+        let (buffer, was_pool_allocated) = memory_pool().acquire_buffer(capacity.max(ALIGNMENT));
         let original_capacity = buffer.capacity();
         let original_bucket_idx = if was_pool_allocated {
             memory_pool().best_fit(original_capacity)
         } else {
             None
         };
+
+        debug_assert_eq!(
+            buffer.as_ptr() as usize % ALIGNMENT,
+            0,
+            "PooledBuffer not aligned to {} bytes",
+            ALIGNMENT
+        );
+
         Self {
             from_pool: was_pool_allocated,
             original_capacity,
@@ -63,12 +75,12 @@ impl PooledBuffer {
         }
     }
 
-    /// Creates a new pooled buffer from an existing `BytesMut`.
+    /// Creates a new pooled buffer from an existing `AlignedBuffer`.
     ///
     /// # Arguments
     ///
-    /// * `existing` - The existing `BytesMut` buffer
-    pub fn from_existing(existing: BytesMut) -> Self {
+    /// * `existing` - The existing `AlignedBuffer` buffer
+    pub fn from_existing(existing: AlignedBuffer) -> Self {
         Self {
             from_pool: false,
             original_capacity: existing.capacity(),
@@ -83,7 +95,7 @@ impl PooledBuffer {
             from_pool: false,
             original_capacity: 0,
             original_bucket_idx: None,
-            inner: BytesMut::new(),
+            inner: AlignedBuffer::new(ALIGNMENT),
         }
     }
 
@@ -127,6 +139,52 @@ impl PooledBuffer {
         }
     }
 
+    /// Split the buffer at given position, returning a new PooledBuffer
+    /// containing byte [0, at) and leaving [at, len)
+    ///
+    /// # Panic
+    /// Panics if at > len
+    pub fn split_to(&mut self, at: usize) -> PooledBuffer {
+        assert!(
+            at <= self.len(),
+            "split_to out of bounds: at={}, len={}",
+            at,
+            self.len()
+        );
+
+        let mut new_buff = PooledBuffer::with_capacity(at);
+        new_buff.inner.extend_from_slice(&self.inner[..at]);
+
+        // SAFETY:
+        // - `self.inner.as_ptr().add(at)` is valid for `new_len` because
+        // `at + new_len === old_len <= cap`. Similar with `self.inner.as_mut_ptr()`
+        //
+        // -  source range is `[at, at + new_len)` and the destination is
+        //   `[0, new_len)`.  These ranges do not overlap when `at > 0`.
+        // - when `at == 0`, the operation is noop
+        let new_len = self.len() - at;
+        if new_len > 0 {
+            unsafe {
+                // move [at..] to [0..]
+                std::ptr::copy(
+                    self.inner.as_ptr().add(at),
+                    self.inner.as_mut_ptr(),
+                    new_len,
+                );
+
+                self.inner.set_len(new_len);
+            }
+        } else {
+            self.inner.clear();
+        }
+
+        new_buff
+    }
+
+    pub fn put<T: AsRef<[u8]>>(&mut self, src: T) {
+        self.extend_from_slice(src.as_ref());
+    }
+
     /// Wrapper for extend_from_slice which might cause resize
     pub fn extend_from_slice(&mut self, extend_from: &[u8]) {
         let before_cap = self.inner.capacity();
@@ -140,7 +198,9 @@ impl PooledBuffer {
     /// Wrapper for put_bytes which might cause resize
     pub fn put_bytes(&mut self, byte: u8, len: usize) {
         let before_cap = self.inner.capacity();
-        self.inner.put_bytes(byte, len);
+
+        let start = self.inner.len();
+        self.inner.resize(start + len, byte);
 
         if self.inner.capacity() != before_cap {
             self.check_for_resize();
@@ -149,18 +209,18 @@ impl PooledBuffer {
 
     /// Wrapper for put_slice which might cause resize
     pub fn put_slice(&mut self, src: &[u8]) {
-        let before_cap = self.inner.capacity();
-        self.inner.put_slice(src);
-
-        if self.inner.capacity() != before_cap {
-            self.check_for_resize();
-        }
+        self.extend_from_slice(src);
+        // let before_cap = self.inner.capacity();
+        //
+        // if self.inner.capacity() != before_cap {
+        //     self.check_for_resize();
+        // }
     }
 
     /// Wrapper for put_u32_le which might cause resize
     pub fn put_u32_le(&mut self, value: u32) {
         let before_cap = self.inner.capacity();
-        self.inner.put_u32_le(value);
+        self.inner.extend_from_slice(&value.to_le_bytes());
 
         if self.inner.capacity() != before_cap {
             self.check_for_resize();
@@ -170,7 +230,7 @@ impl PooledBuffer {
     /// Wrapper for put_u64_le which might cause resize
     pub fn put_u64_le(&mut self, value: u64) {
         let before_cap = self.inner.capacity();
-        self.inner.put_u64_le(value);
+        self.inner.extend_from_slice(&value.to_le_bytes());
 
         if self.inner.capacity() != before_cap {
             self.check_for_resize();
@@ -192,11 +252,12 @@ impl PooledBuffer {
         self.inner.is_empty()
     }
 
-    /// Consumes the PooledBuffer and returns the inner BytesMut.
+    /// Consumes the PooledBuffer and returns the inner AlignedBuffer.
     /// Note: This bypasses pool return logic, use with caution.
-    pub fn into_inner(self) -> BytesMut {
+    pub fn into_inner(self) -> AlignedBuffer {
         let mut this = std::mem::ManuallyDrop::new(self);
-        std::mem::take(&mut this.inner)
+
+        std::mem::replace(&mut this.inner, AlignedBuffer::new(ALIGNMENT))
     }
 
     /// Freezes the buffer, converting it to an immutable `Bytes`.
@@ -205,24 +266,26 @@ impl PooledBuffer {
     /// return memory to the pool on drop (the frozen Bytes owns the allocation).
     /// The returned `Bytes` is Arc-backed, allowing cheap clones.
     pub fn freeze(&mut self) -> Bytes {
-        // Decrement pool counter since memory is transferred to Bytes
-        // and won't be returned to the pool.
+        let buf = std::mem::replace(&mut self.inner, AlignedBuffer::new(ALIGNMENT));
+
+        // Update pool accounting
         if self.from_pool
             && let Some(bucket_idx) = self.original_bucket_idx
         {
             memory_pool().dec_bucket_in_use(bucket_idx);
         }
-
-        let inner = std::mem::take(&mut self.inner);
         self.from_pool = false;
         self.original_capacity = 0;
         self.original_bucket_idx = None;
-        inner.freeze()
+
+        // Zero copy: Bytes takes ownership of the AlignedBuffer
+        // and will drop it when refcount reaches zero
+        Bytes::from_owner(buf)
     }
 }
 
 impl Deref for PooledBuffer {
-    type Target = BytesMut;
+    type Target = AlignedBuffer;
 
     fn deref(&self) -> &Self::Target {
         &self.inner
@@ -238,7 +301,7 @@ impl DerefMut for PooledBuffer {
 impl Drop for PooledBuffer {
     fn drop(&mut self) {
         if self.from_pool {
-            let buf = std::mem::take(&mut self.inner);
+            let buf = std::mem::replace(&mut self.inner, AlignedBuffer::new(ALIGNMENT));
             buf.return_to_pool(self.original_capacity, true);
         }
     }
@@ -252,27 +315,15 @@ impl From<&[u8]> for PooledBuffer {
     }
 }
 
-impl From<BytesMut> for PooledBuffer {
-    fn from(bytes: BytesMut) -> Self {
-        Self::from_existing(bytes)
+impl AsRef<[u8]> for PooledBuffer {
+    fn as_ref(&self) -> &[u8] {
+        &self.inner
     }
 }
 
-impl Buf for PooledBuffer {
-    fn remaining(&self) -> usize {
-        self.inner.remaining()
-    }
-
-    fn chunk(&self) -> &[u8] {
-        self.inner.chunk()
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        Buf::advance(&mut self.inner, cnt)
-    }
-
-    fn chunks_vectored<'t>(&'t self, dst: &mut [std::io::IoSlice<'t>]) -> usize {
-        self.inner.chunks_vectored(dst)
+impl From<AlignedBuffer> for PooledBuffer {
+    fn from(buffer: AlignedBuffer) -> Self {
+        Self::from_existing(buffer)
     }
 }
 

{apache_iggy-0.7.4.dev1 → apache_iggy-0.7.5.dev1}/core/common/src/alloc/memory_pool.rs

@@ -16,7 +16,7 @@
  * under the License.
  */
 
-use bytes::BytesMut;
+use aligned_vec::{AVec, ConstAlign};
 use crossbeam::queue::ArrayQueue;
 use human_repr::HumanCount;
 use once_cell::sync::OnceCell;
@@ -24,18 +24,17 @@ use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use tracing::{info, trace, warn};
 
+pub const ALIGNMENT: usize = 4096;
+pub type AlignedBuffer = AVec<u8, ConstAlign<4096>>;
+
 /// Global memory pool instance. Use `memory_pool()` to access it.
 pub static MEMORY_POOL: OnceCell<MemoryPool> = OnceCell::new();
 
 /// Total number of distinct bucket sizes.
-const NUM_BUCKETS: usize = 32;
+const NUM_BUCKETS: usize = 28;
 
 /// Array of bucket sizes in ascending order. Each entry is a distinct buffer size (in bytes).
 const BUCKET_SIZES: [usize; NUM_BUCKETS] = [
-    256,
-    512,
-    1024,
-    2 * 1024,
     4 * 1024,
     8 * 1024,
     16 * 1024,
@@ -87,7 +86,7 @@ pub struct MemoryPoolConfigOther {
     pub bucket_capacity: u32,
 }
 
-/// A memory pool that maintains fixed-size buckets for reusing `BytesMut` buffers.
+/// A memory pool that maintains fixed-size buckets for reusing `AlignedBuffer` buffers.
 ///
 /// Each bucket corresponds to a particular size in `BUCKET_SIZES`. The pool tracks:
 /// - Buffers currently in use (`in_use`)
@@ -109,7 +108,7 @@ pub struct MemoryPool {
     /// Array of queues for reusable buffers. Each queue can store up to `bucket_capacity` buffers.
     /// The length of each queue (`buckets[i].len()`) is how many **free** buffers are currently available.
     /// Free doesn't mean the buffer is allocated, it just means it's not in use.
-    buckets: [Arc<ArrayQueue<BytesMut>>; NUM_BUCKETS],
+    buckets: [Arc<ArrayQueue<AlignedBuffer>>; NUM_BUCKETS],
 
     /// Number of buffers **in use** for each bucket size (grow/shrink as they are acquired/released).
     in_use: [Arc<AtomicUsize>; NUM_BUCKETS],
@@ -175,29 +174,47 @@ impl MemoryPool {
             MEMORY_POOL.get_or_init(|| MemoryPool::new(is_enabled, memory_limit, bucket_capacity));
     }
 
-    /// Acquire a `BytesMut` buffer with at least `capacity` bytes.
+    /// Acquire a `AlignedBuffer` buffer with at least `capacity` bytes.
     ///
     /// - If a bucket can fit `capacity`, try to pop from its free buffer queue; otherwise create a new buffer.
     /// - If `memory_limit` would be exceeded, allocate outside the pool.
     ///
     /// Returns a tuple of (buffer, was_pool_allocated) where was_pool_allocated indicates if the buffer
     /// was allocated from the pool (true) or externally (false).
-    pub fn acquire_buffer(&self, capacity: usize) -> (BytesMut, bool) {
+    pub fn acquire_buffer(&self, capacity: usize) -> (AlignedBuffer, bool) {
         if !self.is_enabled {
-            return (BytesMut::with_capacity(capacity), false);
+            return (allocate_aligned_buffer(capacity), false);
         }
 
         let current = self.pool_current_size();
 
         match self.best_fit(capacity) {
             Some(idx) => {
+                let new_size = BUCKET_SIZES[idx];
+
                 if let Some(mut buf) = self.buckets[idx].pop() {
                     buf.clear();
+
+                    if buf.capacity() < capacity {
+                        warn!(
+                            "Pooled buffer too small! bucket[{}]={}, buf.capacity()={}, requested={}. Dropping and allocating new.",
+                            idx,
+                            new_size,
+                            buf.capacity(),
+                            capacity
+                        );
+                        drop(buf);
+
+                        let new_buf = allocate_aligned_buffer(new_size);
+                        self.inc_bucket_alloc(idx);
+                        self.inc_bucket_in_use(idx);
+                        return (new_buf, true);
+                    }
+
                     self.inc_bucket_in_use(idx);
                     return (buf, true);
                 }
 
-                let new_size = BUCKET_SIZES[idx];
                 if current + new_size > self.memory_limit {
                     self.set_capacity_warning(true);
                     trace!(
@@ -205,12 +222,12 @@ impl MemoryPool {
                         new_size, current, self.memory_limit
                     );
                     self.inc_external_allocations();
-                    return (BytesMut::with_capacity(new_size), false);
+                    return (allocate_aligned_buffer(new_size), false);
                 }
 
                 self.inc_bucket_alloc(idx);
                 self.inc_bucket_in_use(idx);
-                (BytesMut::with_capacity(new_size), true)
+                (allocate_aligned_buffer(new_size), true)
             }
             None => {
                 if current + capacity > self.memory_limit {
@@ -219,16 +236,16 @@ impl MemoryPool {
                         capacity, current, self.memory_limit
                     );
                     self.inc_external_allocations();
-                    return (BytesMut::with_capacity(capacity), false);
+                    return (allocate_aligned_buffer(capacity), false);
                 }
 
                 self.inc_external_allocations();
-                (BytesMut::with_capacity(capacity), false)
+                (allocate_aligned_buffer(capacity), false)
             }
         }
     }
 
-    /// Return a `BytesMut` buffer previously acquired from the pool.
+    /// Return a `AlignedBuffer` buffer previously acquired from the pool.
     ///
     /// - If `current_capacity` differs from `original_capacity`, increments `resize_events`.
     /// - If a matching bucket exists, place it back in that bucket's queue (if space is available).
@@ -236,7 +253,7 @@ impl MemoryPool {
     /// - The `was_pool_allocated` flag indicates if this buffer was originally allocated from the pool.
     pub fn release_buffer(
         &self,
-        buffer: BytesMut,
+        buffer: AlignedBuffer,
         original_capacity: usize,
         was_pool_allocated: bool,
     ) {
@@ -448,16 +465,21 @@ impl MemoryPool {
 
 /// Return a buffer to the pool by calling `release_buffer` with the original capacity.
 /// This extension trait makes it easy to do `some_bytes.return_to_pool(orig_cap, was_pool_allocated)`.
-pub trait BytesMutExt {
+pub trait AlignedBufferExt {
     fn return_to_pool(self, original_capacity: usize, was_pool_allocated: bool);
 }
 
-impl BytesMutExt for BytesMut {
+impl AlignedBufferExt for AlignedBuffer {
     fn return_to_pool(self, original_capacity: usize, was_pool_allocated: bool) {
         memory_pool().release_buffer(self, original_capacity, was_pool_allocated);
     }
 }
 
+fn allocate_aligned_buffer(capacity: usize) -> AlignedBuffer {
+    let aligned_capacity = capacity.next_multiple_of(ALIGNMENT).max(ALIGNMENT);
+    AlignedBuffer::with_capacity(ALIGNMENT, aligned_capacity)
+}
+
 /// Convert a size in bytes to a string like "8KiB" or "2MiB".
 fn size_str(size: usize) -> String {
     if size >= 1024 * 1024 {

{apache_iggy-0.7.4.dev1 → apache_iggy-0.7.5.dev1}/core/common/src/commands/messages/send_messages.rs

@@ -203,12 +203,19 @@ impl Serialize for SendMessages {
                 let payload_base64 = BASE64.encode(msg_view.payload());
                 map.insert("payload", serde_json::to_value(payload_base64).unwrap());
 
-                if let Ok(Some(headers)) = msg_view.user_headers_map() {
-                    let entries: Vec<HeaderEntry> = headers
-                        .into_iter()
-                        .map(|(k, v)| HeaderEntry { key: k, value: v })
-                        .collect();
-                    map.insert("user_headers", serde_json::to_value(&entries).unwrap());
+                match msg_view.user_headers_map() {
+                    Ok(Some(headers)) => {
+                        let entries: Vec<HeaderEntry> = headers
+                            .into_iter()
+                            .map(|(k, v)| HeaderEntry { key: k, value: v })
+                            .collect();
+                        map.insert("user_headers", serde_json::to_value(&entries).unwrap());
+                    }
+                    _ if msg_view.user_headers().is_some() => {
+                        let raw_base64 = BASE64.encode(msg_view.user_headers().unwrap());
+                        map.insert("user_headers", serde_json::to_value(raw_base64).unwrap());
+                    }
+                    _ => {}
                 }
 
                 map
@@ -310,29 +317,38 @@ impl<'de> Deserialize<'de> for SendMessages {
                                     .decode(payload)
                                     .map_err(|_| de::Error::custom("Invalid base64 payload"))?;
 
-                                let headers_map = if let Some(headers) = msg.get("user_headers") {
-                                    if headers.is_null() {
-                                        None
-                                    } else {
-                                        let entries: Vec<HeaderEntry> = serde_json::from_value(
-                                            headers.clone(),
-                                        )
-                                        .map_err(|e| {
-                                            de::Error::custom(format!(
-                                                "Invalid headers format: {e}"
-                                            ))
-                                        })?;
-                                        let mut map = HashMap::new();
-                                        for entry in entries {
-                                            map.insert(entry.key, entry.value);
+                                let (headers_map, raw_headers) =
+                                    if let Some(headers) = msg.get("user_headers") {
+                                        if headers.is_null() {
+                                            (None, None)
+                                        } else if let Some(base64_str) = headers.as_str() {
+                                            // Raw base64-encoded header bytes (e.g. client-side encrypted)
+                                            let raw = BASE64.decode(base64_str).map_err(|e| {
+                                                de::Error::custom(format!(
+                                                    "Invalid base64 headers: {e}"
+                                                ))
+                                            })?;
+                                            (None, Some(Bytes::from(raw)))
+                                        } else {
+                                            let entries: Vec<HeaderEntry> = serde_json::from_value(
+                                                headers.clone(),
+                                            )
+                                            .map_err(|e| {
+                                                de::Error::custom(format!(
+                                                    "Invalid headers format: {e}"
+                                                ))
+                                            })?;
+                                            let mut map = HashMap::new();
+                                            for entry in entries {
+                                                map.insert(entry.key, entry.value);
+                                            }
+                                            (Some(map), None)
                                         }
-                                        Some(map)
-                                    }
-                                } else {
-                                    None
-                                };
+                                    } else {
+                                        (None, None)
+                                    };
 
-                                let iggy_message = if let Some(headers) = headers_map {
+                                let mut iggy_message = if let Some(headers) = headers_map {
                                     IggyMessage::builder()
                                         .id(id)
                                         .payload(payload_bytes.into())
@@ -355,6 +371,11 @@ impl<'de> Deserialize<'de> for SendMessages {
                                         })?
                                 };
 
+                                if let Some(raw) = raw_headers {
+                                    iggy_message.header.user_headers_length = raw.len() as u32;
+                                    iggy_message.user_headers = Some(raw);
+                                }
+
                                 iggy_messages.push(iggy_message);
                             }
 

{apache_iggy-0.7.4.dev1 → apache_iggy-0.7.5.dev1}/core/common/src/lib.rs

@@ -96,7 +96,6 @@ pub use types::configuration::websocket_config::websocket_client_config::*;
 pub use types::configuration::websocket_config::websocket_client_config_builder::*;
 pub use types::configuration::websocket_config::websocket_client_reconnection_config::*;
 pub use types::configuration::websocket_config::websocket_connection_string_options::*;
-pub use types::consensus::*;
 pub use types::consumer::consumer_group::*;
 pub use types::consumer::consumer_group_id::*;
 pub use types::consumer::consumer_group_offsets::*;

{apache_iggy-0.7.4.dev1 → apache_iggy-0.7.5.dev1}/core/common/src/traits/binary_mapper.rs

@@ -24,7 +24,6 @@ use crate::{
     Stream, StreamDetails, Topic, TopicDetails, UserInfo, UserInfoDetails, UserStatus,
 };
 use bytes::Bytes;
-use secrecy::SecretString;
 use std::collections::HashMap;
 use std::str::from_utf8;
 
@@ -508,9 +507,7 @@ pub fn map_raw_pat(payload: Bytes) -> Result<RawPersonalAccessToken, IggyError>
     let token = from_utf8(&payload[1..1 + token_length as usize])
         .map_err(|_| IggyError::InvalidUtf8)?
         .to_string();
-    Ok(RawPersonalAccessToken {
-        token: SecretString::from(token),
-    })
+    Ok(RawPersonalAccessToken { token })
 }
 
 pub fn map_client(payload: Bytes) -> Result<ClientInfoDetails, IggyError> {