//! Access logger support for dynamic modules.

//!

//! This module provides traits and types for implementing access loggers as dynamic modules.

use crate::{abi, EnvoyBuffer};

use std::ffi::c_void;

use std::ptr;

// -----------------------------------------------------------------------------

// Metrics Support

// -----------------------------------------------------------------------------

/// Handle for a counter metric. Counters can only be incremented.

#[derive(Debug, Clone, Copy)]

pub struct CounterHandle {

  id: usize,

}

/// Handle for a gauge metric. Gauges can be set, incremented, or decremented.

#[derive(Debug, Clone, Copy)]

pub struct GaugeHandle {

  id: usize,

}

/// Handle for a histogram metric. Histograms record value distributions.

#[derive(Debug, Clone, Copy)]

pub struct HistogramHandle {

  id: usize,

}

/// Provides access to metrics operations during configuration.

///

/// This is passed to `AccessLoggerConfig::new` to allow defining metrics.

pub struct ConfigContext {

  envoy_ptr: *mut c_void,

}

impl ConfigContext {

  /// Create a new ConfigContext. Used internally by the macro.

  #[doc(hidden)]

  pub fn new(envoy_ptr: *mut c_void) -> Self {

    Self { envoy_ptr }

  }

  /// Define a counter metric.

  ///

  /// Counters are cumulative metrics that can only increase. They are reset on restart.

  /// Returns a handle that can be used to increment the counter.

  pub fn define_counter(&self, name: &str) -> Option<CounterHandle> {

    let name_buf = abi::envoy_dynamic_module_type_module_buffer {

      ptr: name.as_ptr() as *const _,

      length: name.len(),

    };

    let mut id: usize = 0;

    let result = unsafe {

      abi::envoy_dynamic_module_callback_access_logger_config_define_counter(

        self.envoy_ptr,

        name_buf,

        &mut id,

      )

    };

    if result == abi::envoy_dynamic_module_type_metrics_result::Success {

      Some(CounterHandle { id })

    } else {

      None

    }

  }

  /// Define a gauge metric.

  ///

  /// Gauges are metrics that can go up and down. They represent a current value.

  /// Returns a handle that can be used to set/increment/decrement the gauge.

  pub fn define_gauge(&self, name: &str) -> Option<GaugeHandle> {

    let name_buf = abi::envoy_dynamic_module_type_module_buffer {

      ptr: name.as_ptr() as *const _,

      length: name.len(),

    };

    let mut id: usize = 0;

    let result = unsafe {

      abi::envoy_dynamic_module_callback_access_logger_config_define_gauge(

        self.envoy_ptr,

        name_buf,

        &mut id,

      )

    };

    if result == abi::envoy_dynamic_module_type_metrics_result::Success {

      Some(GaugeHandle { id })

    } else {

      None

    }

  }

  /// Define a histogram metric.

  ///

  /// Histograms track the distribution of values. They are useful for measuring latencies.

  /// Returns a handle that can be used to record values in the histogram.

  pub fn define_histogram(&self, name: &str) -> Option<HistogramHandle> {

    let name_buf = abi::envoy_dynamic_module_type_module_buffer {

      ptr: name.as_ptr() as *const _,

      length: name.len(),

    };

    let mut id: usize = 0;

    let result = unsafe {

      abi::envoy_dynamic_module_callback_access_logger_config_define_histogram(

        self.envoy_ptr,

        name_buf,

        &mut id,

      )

    };

    if result == abi::envoy_dynamic_module_type_metrics_result::Success {

      Some(HistogramHandle { id })

    } else {

      None

    }

  }

  /// Get the raw Envoy pointer. Used internally.

  #[doc(hidden)]

  pub fn envoy_ptr(&self) -> *mut c_void {

    self.envoy_ptr

  }

}

/// Provides access to metrics operations at runtime.

///

/// This is stored in the logger and used to update metric values during log events.

pub struct MetricsContext {

  envoy_ptr: *mut c_void,

}

// SAFETY: The envoy_ptr points to Envoy's DynamicModuleAccessLogConfig which is thread-safe.

// The metrics callbacks are designed to be called from any thread.

unsafe impl Send for MetricsContext {}

impl MetricsContext {

  /// Create a new MetricsContext. Used internally by the macro.

  #[doc(hidden)]

  pub fn new(envoy_ptr: *mut c_void) -> Self {

    Self { envoy_ptr }

  }

  /// Increment a counter by the given value.

  pub fn increment_counter(&self, handle: CounterHandle, value: u64) -> bool {

    let result = unsafe {

      abi::envoy_dynamic_module_callback_access_logger_increment_counter(

        self.envoy_ptr,

        handle.id,

        value,

      )

    };

    result == abi::envoy_dynamic_module_type_metrics_result::Success

  }

  /// Set a gauge to the given value.

  pub fn set_gauge(&self, handle: GaugeHandle, value: u64) -> bool {

    let result = unsafe {

      abi::envoy_dynamic_module_callback_access_logger_set_gauge(self.envoy_ptr, handle.id, value)

    };

    result == abi::envoy_dynamic_module_type_metrics_result::Success

  }

  /// Increment a gauge by the given value.

  pub fn increment_gauge(&self, handle: GaugeHandle, value: u64) -> bool {

    let result = unsafe {

      abi::envoy_dynamic_module_callback_access_logger_increment_gauge(

        self.envoy_ptr,

        handle.id,

        value,

      )

    };

    result == abi::envoy_dynamic_module_type_metrics_result::Success

  }

  /// Decrement a gauge by the given value.

  pub fn decrement_gauge(&self, handle: GaugeHandle, value: u64) -> bool {

    let result = unsafe {

      abi::envoy_dynamic_module_callback_access_logger_decrement_gauge(

        self.envoy_ptr,

        handle.id,

        value,

      )

    };

    result == abi::envoy_dynamic_module_type_metrics_result::Success

  }

  /// Record a value in a histogram.

  pub fn record_histogram(&self, handle: HistogramHandle, value: u64) -> bool {

    let result = unsafe {

      abi::envoy_dynamic_module_callback_access_logger_record_histogram_value(

        self.envoy_ptr,

        handle.id,

        value,

      )

    };

    result == abi::envoy_dynamic_module_type_metrics_result::Success

  }

}

/// Trait that the dynamic module must implement to provide the access logger configuration.

pub trait AccessLoggerConfig: Sized + Send + Sync + 'static {

  /// Create a new configuration from the provided name and config bytes.

  ///

  /// The `ctx` provides access to metrics definition APIs. Metrics should be defined

  /// during configuration creation and the handles stored in the config for later use.

  fn new(ctx: &ConfigContext, name: &str, config: &[u8]) -> Result<Self, String>;

  /// Create a logger instance. Called per-thread for thread-local loggers.

  ///

  /// The `metrics` context is stored and can be used to update metrics during log events.

  fn create_logger(

    &self,

    metrics: MetricsContext,

    logger_envoy_ptr: *mut ::std::ffi::c_void,

  ) -> Box<dyn AccessLogger>;

}

/// Logger trait that handles individual log events.

pub trait AccessLogger: Send {

  /// Called when a log event occurs.

  fn log(&mut self, ctx: &LogContext);

  /// Called to flush buffered logs before the logger is destroyed.

  ///

  /// This is called during shutdown when the thread-local logger is being destroyed.

  /// Modules that buffer log entries should implement this to ensure no logs are lost.

  ///

  /// This is optional. The default implementation does nothing.

  fn flush(&mut self) {}

}

/// Timing information from the stream info.

#[derive(Debug, Clone, Default)]

pub struct TimingInfo {

  /// Request start time as Unix timestamp in nanoseconds.

  pub start_time_unix_ns: i64,

  /// Duration from start to request complete in nanoseconds, or -1 if not available.

  pub request_complete_duration_ns: i64,

  /// Time of first upstream TX byte sent in nanoseconds, or -1 if not available.

  pub first_upstream_tx_byte_sent_ns: i64,

  /// Time of last upstream TX byte sent in nanoseconds, or -1 if not available.

  pub last_upstream_tx_byte_sent_ns: i64,

  /// Time of first upstream RX byte received in nanoseconds, or -1 if not available.

  pub first_upstream_rx_byte_received_ns: i64,

  /// Time of last upstream RX byte received in nanoseconds, or -1 if not available.

  pub last_upstream_rx_byte_received_ns: i64,

  /// Time of first downstream TX byte sent in nanoseconds, or -1 if not available.

  pub first_downstream_tx_byte_sent_ns: i64,

  /// Time of last downstream TX byte sent in nanoseconds, or -1 if not available.

  pub last_downstream_tx_byte_sent_ns: i64,

}

/// Byte count information from the stream info.

#[derive(Debug, Clone, Default)]

pub struct BytesInfo {

  /// Total bytes received from downstream.

  pub bytes_received: u64,

  /// Total bytes sent to downstream.

  pub bytes_sent: u64,

  /// Wire bytes received (including TLS overhead).

  pub wire_bytes_received: u64,

  /// Wire bytes sent (including TLS overhead).

  pub wire_bytes_sent: u64,

}

/// Access log type indicating when the log was recorded.

///

/// This corresponds to `envoy::data::accesslog::v3::AccessLogType`.

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

#[repr(u32)]

pub enum AccessLogType {

  NotSet               = 0,

  TcpUpstreamConnected = 1,

  TcpPeriodic          = 2,

  TcpConnectionEnd     = 3,

  DownstreamStart      = 4,

  DownstreamPeriodic   = 5,

  DownstreamEnd        = 6,

  UpstreamPoolReady    = 7,

  UpstreamPeriodic     = 8,

  UpstreamEnd          = 9,

  DownstreamTunnelSuccessfullyEstablished = 10,

  UdpTunnelUpstreamConnected = 11,

  UdpPeriodic          = 12,

  UdpSessionEnd        = 13,

}

impl AccessLogType {

  /// Convert from the ABI enum value. Used internally by the macro.

  #[doc(hidden)]

  pub fn from_abi(value: abi::envoy_dynamic_module_type_access_log_type) -> Self {

    match value {

      abi::envoy_dynamic_module_type_access_log_type::TcpUpstreamConnected => {

        AccessLogType::TcpUpstreamConnected

      },

      abi::envoy_dynamic_module_type_access_log_type::TcpPeriodic => AccessLogType::TcpPeriodic,

      abi::envoy_dynamic_module_type_access_log_type::TcpConnectionEnd => {

        AccessLogType::TcpConnectionEnd

      },

      abi::envoy_dynamic_module_type_access_log_type::DownstreamStart => {

        AccessLogType::DownstreamStart

      },

      abi::envoy_dynamic_module_type_access_log_type::DownstreamPeriodic => {

        AccessLogType::DownstreamPeriodic

      },

      abi::envoy_dynamic_module_type_access_log_type::DownstreamEnd => AccessLogType::DownstreamEnd,

      abi::envoy_dynamic_module_type_access_log_type::UpstreamPoolReady => {

        AccessLogType::UpstreamPoolReady

      },

      abi::envoy_dynamic_module_type_access_log_type::UpstreamPeriodic => {

        AccessLogType::UpstreamPeriodic

      },

      abi::envoy_dynamic_module_type_access_log_type::UpstreamEnd => AccessLogType::UpstreamEnd,

      abi::envoy_dynamic_module_type_access_log_type::DownstreamTunnelSuccessfullyEstablished => {

        AccessLogType::DownstreamTunnelSuccessfullyEstablished

      },

      abi::envoy_dynamic_module_type_access_log_type::UdpTunnelUpstreamConnected => {

        AccessLogType::UdpTunnelUpstreamConnected

      },

      abi::envoy_dynamic_module_type_access_log_type::UdpPeriodic => AccessLogType::UdpPeriodic,

      abi::envoy_dynamic_module_type_access_log_type::UdpSessionEnd => AccessLogType::UdpSessionEnd,

      _ => AccessLogType::NotSet,

    }

  }

  /// Get the string representation matching Envoy's `AccessLogType_Name`.

  pub fn as_str(&self) -> &'static str {

    match self {

      AccessLogType::NotSet => "NotSet",

      AccessLogType::TcpUpstreamConnected => "TcpUpstreamConnected",

      AccessLogType::TcpPeriodic => "TcpPeriodic",

      AccessLogType::TcpConnectionEnd => "TcpConnectionEnd",

      AccessLogType::DownstreamStart => "DownstreamStart",

      AccessLogType::DownstreamPeriodic => "DownstreamPeriodic",

      AccessLogType::DownstreamEnd => "DownstreamEnd",

      AccessLogType::UpstreamPoolReady => "UpstreamPoolReady",

      AccessLogType::UpstreamPeriodic => "UpstreamPeriodic",

      AccessLogType::UpstreamEnd => "UpstreamEnd",

      AccessLogType::DownstreamTunnelSuccessfullyEstablished => {

        "DownstreamTunnelSuccessfullyEstablished"

      },

      AccessLogType::UdpTunnelUpstreamConnected => "UdpTunnelUpstreamConnected",

      AccessLogType::UdpPeriodic => "UdpPeriodic",

      AccessLogType::UdpSessionEnd => "UdpSessionEnd",

    }

  }

}

/// Read-only context for accessing log event data.

pub struct LogContext {

  // Private field - only accessible within this crate.

  pub(crate) envoy_ptr: *mut c_void,

  /// The type of access log event.

  pub(crate) log_type: AccessLogType,

}

impl LogContext {

  /// Create a new LogContext. Used internally by the macro.

  #[doc(hidden)]

  pub fn new(envoy_ptr: *mut c_void, log_type: AccessLogType) -> Self {

    Self {

      envoy_ptr,

      log_type,

    }

  }

  /// Get the access log type indicating when this log event was recorded.

  pub fn log_type(&self) -> AccessLogType {

    self.log_type

  }

  /// Get the HTTP response code.

  pub fn response_code(&self) -> Option<u32> {

    let code =

      unsafe { abi::envoy_dynamic_module_callback_access_logger_get_response_code(self.envoy_ptr) };

    if code != 0 {

      Some(code)

    } else {

      None

    }

  }

  /// Get the response code details string.

  pub fn response_code_details(&self) -> Option<EnvoyBuffer<'_>> {

    self

      .get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_response_code_details)

  }

  /// Get the request protocol (e.g., "HTTP/1.1", "HTTP/2").

  pub fn protocol(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_protocol)

  }

  /// Get timing information.

  pub fn timing_info(&self) -> TimingInfo {

    let mut info = abi::envoy_dynamic_module_type_timing_info {

      start_time_unix_ns: 0,

      request_complete_duration_ns: -1,

      first_upstream_tx_byte_sent_ns: -1,

      last_upstream_tx_byte_sent_ns: -1,

      first_upstream_rx_byte_received_ns: -1,

      last_upstream_rx_byte_received_ns: -1,

      first_downstream_tx_byte_sent_ns: -1,

      last_downstream_tx_byte_sent_ns: -1,

    };

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_timing_info(self.envoy_ptr, &mut info);

    }

    TimingInfo {

      start_time_unix_ns: info.start_time_unix_ns,

      request_complete_duration_ns: info.request_complete_duration_ns,

      first_upstream_tx_byte_sent_ns: info.first_upstream_tx_byte_sent_ns,

      last_upstream_tx_byte_sent_ns: info.last_upstream_tx_byte_sent_ns,

      first_upstream_rx_byte_received_ns: info.first_upstream_rx_byte_received_ns,

      last_upstream_rx_byte_received_ns: info.last_upstream_rx_byte_received_ns,

      first_downstream_tx_byte_sent_ns: info.first_downstream_tx_byte_sent_ns,

      last_downstream_tx_byte_sent_ns: info.last_downstream_tx_byte_sent_ns,

    }

  }

  /// Get byte count information.

  pub fn bytes_info(&self) -> BytesInfo {

    let mut info = abi::envoy_dynamic_module_type_bytes_info {

      bytes_received: 0,

      bytes_sent: 0,

      wire_bytes_received: 0,

      wire_bytes_sent: 0,

    };

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_bytes_info(self.envoy_ptr, &mut info);

    }

    BytesInfo {

      bytes_received: info.bytes_received,

      bytes_sent: info.bytes_sent,

      wire_bytes_received: info.wire_bytes_received,

      wire_bytes_sent: info.wire_bytes_sent,

    }

  }

  /// Get the route name.

  pub fn route_name(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_route_name)

  }

  /// Get the virtual cluster name.

  pub fn virtual_cluster_name(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_virtual_cluster_name)

  }

  /// Check if this is a health check request.

  pub fn is_health_check(&self) -> bool {

    unsafe { abi::envoy_dynamic_module_callback_access_logger_is_health_check(self.envoy_ptr) }

  }

  /// Get the upstream cluster name.

  pub fn upstream_cluster(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_upstream_cluster)

  }

  /// Get the upstream host hostname.

  pub fn upstream_host(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_upstream_host)

  }

  /// Get the connection ID, or 0 if not available.

  pub fn connection_id(&self) -> u64 {

    unsafe { abi::envoy_dynamic_module_callback_access_logger_get_connection_id(self.envoy_ptr) }

  }

  /// Check if mTLS was used for the connection.

  pub fn is_mtls(&self) -> bool {

    unsafe { abi::envoy_dynamic_module_callback_access_logger_is_mtls(self.envoy_ptr) }

  }

  /// Get the requested server name (SNI).

  pub fn requested_server_name(&self) -> Option<EnvoyBuffer<'_>> {

    self

      .get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_requested_server_name)

  }

  /// Check if the request was sampled for tracing.

  pub fn is_trace_sampled(&self) -> bool {

    unsafe { abi::envoy_dynamic_module_callback_access_logger_is_trace_sampled(self.envoy_ptr) }

  }

  /// Get a request header value by key.

  ///

  /// For headers with multiple values, use `index` to access subsequent values.

  /// Returns the total count of values in `total_count` if provided.

  pub fn get_request_header(&self, key: &str) -> Option<EnvoyBuffer<'_>> {

    self.get_header_value(

      abi::envoy_dynamic_module_type_http_header_type::RequestHeader,

      key,

      0,

    )

  }

  /// Get a response header value by key.

  pub fn get_response_header(&self, key: &str) -> Option<EnvoyBuffer<'_>> {

    self.get_header_value(

      abi::envoy_dynamic_module_type_http_header_type::ResponseHeader,

      key,

      0,

    )

  }

  /// Get a header value by type and key.

  fn get_header_value(

    &self,

    header_type: abi::envoy_dynamic_module_type_http_header_type,

    key: &str,

    index: usize,

  ) -> Option<EnvoyBuffer<'_>> {

    let key_buf = abi::envoy_dynamic_module_type_module_buffer {

      ptr: key.as_ptr() as *const _,

      length: key.len(),

    };

    let mut result = abi::envoy_dynamic_module_type_envoy_buffer {

      ptr: ptr::null_mut(),

      length: 0,

    };

    if unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_header_value(

        self.envoy_ptr,

        header_type,

        key_buf,

        &mut result,

        index,

        ptr::null_mut(),

      )

    } {

      Some(unsafe { EnvoyBuffer::new_from_raw(result.ptr as *const u8, result.length) })

    } else {

      None

    }

  }

  /// Get a value from dynamic metadata.

  ///

  /// # Arguments

  /// * `filter_name` - The filter namespace (e.g., "envoy.filters.http.dynamic_module").

  /// * `key` - The key within the filter namespace (e.g., "rbac_policy").

  ///

  /// # Returns

  /// The string value if it exists, None otherwise.

  /// Note: Only string values are currently supported.

  pub fn get_dynamic_metadata(&self, filter_name: &str, key: &str) -> Option<EnvoyBuffer<'_>> {

    let filter_buf = abi::envoy_dynamic_module_type_module_buffer {

      ptr: filter_name.as_ptr() as *const _,

      length: filter_name.len(),

    };

    let key_buf = abi::envoy_dynamic_module_type_module_buffer {

      ptr: key.as_ptr() as *const _,

      length: key.len(),

    };

    let mut result = abi::envoy_dynamic_module_type_envoy_buffer {

      ptr: ptr::null_mut(),

      length: 0,

    };

    if unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_dynamic_metadata(

        self.envoy_ptr,

        filter_buf,

        key_buf,

        &mut result,

      )

    } {

      Some(unsafe { EnvoyBuffer::new_from_raw(result.ptr as *const u8, result.length) })

    } else {

      None

    }

  }

  /// Get the local reply body (if this was a local response).

  pub fn local_reply_body(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_local_reply_body)

  }

  /// Get the index of the current worker thread.

  pub fn get_worker_index(&self) -> u32 {

    unsafe { abi::envoy_dynamic_module_callback_access_logger_get_worker_index(self.envoy_ptr) }

  }

  /// Check if a specific response flag is set.

  ///

  /// Response flags indicate various error conditions or special processing that occurred

  /// during request handling (e.g., upstream connection failure, rate limiting).

  pub fn has_response_flag(&self, flag: abi::envoy_dynamic_module_type_response_flag) -> bool {

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_has_response_flag(self.envoy_ptr, flag)

    }

  }

  /// Get all response flags as a bitmask.

  ///

  /// Each bit corresponds to a response flag value. Use bitwise operations to check

  /// individual flags, or use [`has_response_flag`](Self::has_response_flag) for single flag

  /// checks.

  pub fn response_flags(&self) -> u64 {

    unsafe { abi::envoy_dynamic_module_callback_access_logger_get_response_flags(self.envoy_ptr) }

  }

  /// Get the upstream request attempt count, or 0 if not available.

  pub fn attempt_count(&self) -> u32 {

    unsafe { abi::envoy_dynamic_module_callback_access_logger_get_attempt_count(self.envoy_ptr) }

  }

  /// Get the connection termination details.

  pub fn connection_termination_details(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(

      abi::envoy_dynamic_module_callback_access_logger_get_connection_termination_details,

    )

  }

  /// Get the downstream remote address (client) as an IP address buffer and port.

  ///

  /// Returns `None` if the address is not available or is not an IP address.

  pub fn downstream_remote_address(&self) -> Option<(EnvoyBuffer<'_>, u32)> {

    self.get_address(abi::envoy_dynamic_module_callback_access_logger_get_downstream_remote_address)

  }

  /// Get the downstream local address (Envoy listener) as an IP address buffer and port.

  ///

  /// Returns `None` if the address is not available or is not an IP address.

  pub fn downstream_local_address(&self) -> Option<(EnvoyBuffer<'_>, u32)> {

    self.get_address(abi::envoy_dynamic_module_callback_access_logger_get_downstream_local_address)

  }

  /// Get the upstream remote address (backend) as an IP address buffer and port.

  ///

  /// Returns `None` if the address is not available or is not an IP address.

  pub fn upstream_remote_address(&self) -> Option<(EnvoyBuffer<'_>, u32)> {

    self.get_address(abi::envoy_dynamic_module_callback_access_logger_get_upstream_remote_address)

  }

  /// Get the upstream local address (Envoy outbound) as an IP address buffer and port.

  ///

  /// Returns `None` if the address is not available or is not an IP address.

  pub fn upstream_local_address(&self) -> Option<(EnvoyBuffer<'_>, u32)> {

    self.get_address(abi::envoy_dynamic_module_callback_access_logger_get_upstream_local_address)

  }

  /// Get the downstream direct remote address (physical peer address before XFF processing).

  ///

  /// Returns `None` if the address is not available or is not an IP address.

  pub fn downstream_direct_remote_address(&self) -> Option<(EnvoyBuffer<'_>, u32)> {

    self.get_address(

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_direct_remote_address,

    )

  }

  /// Get the downstream direct local address (physical listener address).

  ///

  /// Returns `None` if the address is not available or is not an IP address.

  pub fn downstream_direct_local_address(&self) -> Option<(EnvoyBuffer<'_>, u32)> {

    self.get_address(

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_direct_local_address,

    )

  }

  /// Helper to retrieve an address (IP buffer + port) from an ABI callback.

  fn get_address(

    &self,

    callback: unsafe extern "C" fn(

      *mut c_void,

      *mut abi::envoy_dynamic_module_type_envoy_buffer,

      *mut u32,

    ) -> bool,

  ) -> Option<(EnvoyBuffer<'_>, u32)> {

    let mut address = abi::envoy_dynamic_module_type_envoy_buffer {

      ptr: ptr::null_mut(),

      length: 0,

    };

    let mut port: u32 = 0;

    if unsafe { callback(self.envoy_ptr, &mut address, &mut port) } {

      Some((

        unsafe { EnvoyBuffer::new_from_raw(address.ptr as *const u8, address.length) },

        port,

      ))

    } else {

      None

    }

  }

  /// Get the upstream transport failure reason.

  pub fn upstream_transport_failure_reason(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_transport_failure_reason,

    )

  }

  /// Get the JA3 fingerprint hash from the downstream connection.

  pub fn ja3_hash(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_ja3_hash)

  }

  /// Get the JA4 fingerprint hash from the downstream connection.

  pub fn ja4_hash(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_ja4_hash)

  }

  /// Get the downstream transport failure reason.

  pub fn downstream_transport_failure_reason(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_transport_failure_reason,

    )

  }

  /// Get the byte size of request headers (uncompressed).

  pub fn request_headers_bytes(&self) -> u64 {

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_request_headers_bytes(self.envoy_ptr)

    }

  }

  /// Get the byte size of response headers (uncompressed).

  pub fn response_headers_bytes(&self) -> u64 {

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_response_headers_bytes(self.envoy_ptr)

    }

  }

  /// Get the byte size of response trailers (uncompressed).

  pub fn response_trailers_bytes(&self) -> u64 {

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_response_trailers_bytes(self.envoy_ptr)

    }

  }

  /// Get the upstream protocol (e.g., "HTTP/1.1", "HTTP/2").

  pub fn upstream_protocol(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_upstream_protocol)

  }

  /// Get the upstream connection pool ready duration in nanoseconds, or -1 if not available.

  pub fn upstream_connection_pool_ready_duration_ns(&self) -> i64 {

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_pool_ready_duration_ns(

        self.envoy_ptr,

      )

    }

  }

  /// Get the downstream TLS version (e.g., "TLSv1.2", "TLSv1.3").

  pub fn downstream_tls_version(&self) -> Option<EnvoyBuffer<'_>> {

    self

      .get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_downstream_tls_version)

  }

  /// Get the downstream peer certificate subject (e.g., "CN=client").

  pub fn downstream_peer_subject(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_peer_subject,

    )

  }

  /// Get the downstream peer certificate SHA-256 digest.

  pub fn downstream_peer_cert_digest(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_peer_cert_digest,

    )

  }

  /// Get the downstream TLS cipher suite.

  ///

  /// The returned buffer uses thread-local storage and is valid until the next call to

  /// this method or [`upstream_tls_cipher`](Self::upstream_tls_cipher) on the same thread.

  pub fn downstream_tls_cipher(&self) -> Option<EnvoyBuffer<'_>> {

    self

      .get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_downstream_tls_cipher)

  }

  /// Get the downstream TLS session ID.

  pub fn downstream_tls_session_id(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_tls_session_id,

    )

  }

  /// Get the downstream peer certificate issuer.

  pub fn downstream_peer_issuer(&self) -> Option<EnvoyBuffer<'_>> {

    self

      .get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_downstream_peer_issuer)

  }

  /// Get the downstream peer certificate serial number.

  pub fn downstream_peer_serial(&self) -> Option<EnvoyBuffer<'_>> {

    self

      .get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_downstream_peer_serial)

  }

  /// Get the downstream peer certificate SHA-1 fingerprint.

  pub fn downstream_peer_fingerprint_1(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_peer_fingerprint_1,

    )

  }

  /// Get the downstream local certificate subject (Envoy's own certificate).

  pub fn downstream_local_subject(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_local_subject,

    )

  }

  /// Check if the downstream peer certificate was presented.

  pub fn downstream_peer_cert_presented(&self) -> bool {

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_peer_cert_presented(

        self.envoy_ptr,

      )

    }

  }

  /// Check if the downstream peer certificate was validated.

  pub fn downstream_peer_cert_validated(&self) -> bool {

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_peer_cert_validated(

        self.envoy_ptr,

      )

    }

  }

  /// Get the downstream peer certificate validity start time as epoch seconds.

  ///

  /// Returns 0 if the certificate or validity time is not available.

  pub fn downstream_peer_cert_v_start(&self) -> i64 {

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_peer_cert_v_start(

        self.envoy_ptr,

      )

    }

  }

  /// Get the downstream peer certificate validity end time as epoch seconds.

  ///

  /// Returns 0 if the certificate or validity time is not available.

  pub fn downstream_peer_cert_v_end(&self) -> i64 {

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_peer_cert_v_end(

        self.envoy_ptr,

      )

    }

  }

  /// Get the URI Subject Alternative Names from the downstream peer certificate.

  pub fn downstream_peer_uri_san(&self) -> Vec<EnvoyBuffer<'_>> {

    self.get_san_list(

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_peer_uri_san_size,

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_peer_uri_san,

    )

  }

  /// Get the URI Subject Alternative Names from the downstream local certificate.

  pub fn downstream_local_uri_san(&self) -> Vec<EnvoyBuffer<'_>> {

    self.get_san_list(

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_local_uri_san_size,

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_local_uri_san,

    )

  }

  /// Get the DNS Subject Alternative Names from the downstream peer certificate.

  pub fn downstream_peer_dns_san(&self) -> Vec<EnvoyBuffer<'_>> {

    self.get_san_list(

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_peer_dns_san_size,

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_peer_dns_san,

    )

  }

  /// Get the DNS Subject Alternative Names from the downstream local certificate.

  pub fn downstream_local_dns_san(&self) -> Vec<EnvoyBuffer<'_>> {

    self.get_san_list(

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_local_dns_san_size,

      abi::envoy_dynamic_module_callback_access_logger_get_downstream_local_dns_san,

    )

  }

  /// Get the upstream connection ID, or 0 if not available.

  pub fn upstream_connection_id(&self) -> u64 {

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_connection_id(self.envoy_ptr)

    }

  }

  /// Get the upstream TLS version (e.g., "TLSv1.2", "TLSv1.3").

  pub fn upstream_tls_version(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_upstream_tls_version)

  }

  /// Get the upstream TLS cipher suite.

  ///

  /// The returned buffer uses thread-local storage and is valid until the next call to

  /// this method or [`downstream_tls_cipher`](Self::downstream_tls_cipher) on the same thread.

  pub fn upstream_tls_cipher(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_upstream_tls_cipher)

  }

  /// Get the upstream TLS session ID.

  pub fn upstream_tls_session_id(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_tls_session_id,

    )

  }

  /// Get the upstream peer certificate subject.

  pub fn upstream_peer_subject(&self) -> Option<EnvoyBuffer<'_>> {

    self

      .get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_upstream_peer_subject)

  }

  /// Get the upstream peer certificate issuer.

  pub fn upstream_peer_issuer(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_upstream_peer_issuer)

  }

  /// Get the upstream local certificate subject (Envoy's own certificate for the upstream

  /// connection).

  pub fn upstream_local_subject(&self) -> Option<EnvoyBuffer<'_>> {

    self

      .get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_upstream_local_subject)

  }

  /// Get the upstream peer certificate SHA-256 digest.

  pub fn upstream_peer_cert_digest(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_peer_cert_digest,

    )

  }

  /// Get the upstream peer certificate validity start time as epoch seconds.

  ///

  /// Returns 0 if the certificate or validity time is not available.

  pub fn upstream_peer_cert_v_start(&self) -> i64 {

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_peer_cert_v_start(

        self.envoy_ptr,

      )

    }

  }

  /// Get the upstream peer certificate validity end time as epoch seconds.

  ///

  /// Returns 0 if the certificate or validity time is not available.

  pub fn upstream_peer_cert_v_end(&self) -> i64 {

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_peer_cert_v_end(self.envoy_ptr)

    }

  }

  /// Get the URI Subject Alternative Names from the upstream peer certificate.

  pub fn upstream_peer_uri_san(&self) -> Vec<EnvoyBuffer<'_>> {

    self.get_san_list(

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_peer_uri_san_size,

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_peer_uri_san,

    )

  }

  /// Get the URI Subject Alternative Names from the upstream local certificate.

  pub fn upstream_local_uri_san(&self) -> Vec<EnvoyBuffer<'_>> {

    self.get_san_list(

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_local_uri_san_size,

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_local_uri_san,

    )

  }

  /// Get the DNS Subject Alternative Names from the upstream peer certificate.

  pub fn upstream_peer_dns_san(&self) -> Vec<EnvoyBuffer<'_>> {

    self.get_san_list(

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_peer_dns_san_size,

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_peer_dns_san,

    )

  }

  /// Get the DNS Subject Alternative Names from the upstream local certificate.

  pub fn upstream_local_dns_san(&self) -> Vec<EnvoyBuffer<'_>> {

    self.get_san_list(

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_local_dns_san_size,

      abi::envoy_dynamic_module_callback_access_logger_get_upstream_local_dns_san,

    )

  }

  /// Get the request ID (stream ID).

  pub fn request_id(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_request_id)

  }

  /// Get a response trailer value by key.

  pub fn get_response_trailer(&self, key: &str) -> Option<EnvoyBuffer<'_>> {

    self.get_header_value(

      abi::envoy_dynamic_module_type_http_header_type::ResponseTrailer,

      key,

      0,

    )

  }

  /// Get a value from the filter state.

  ///

  /// Note: This is not currently supported and always returns `None`.

  /// Filter state serialization requires allocation which is incompatible

  /// with the zero-copy ABI design.

  pub fn get_filter_state(&self, key: &str) -> Option<EnvoyBuffer<'_>> {

    let key_buf = abi::envoy_dynamic_module_type_module_buffer {

      ptr: key.as_ptr() as *const _,

      length: key.len(),

    };

    let mut result = abi::envoy_dynamic_module_type_envoy_buffer {

      ptr: ptr::null_mut(),

      length: 0,

    };

    if unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_filter_state(

        self.envoy_ptr,

        key_buf,

        &mut result,

      )

    } {

      Some(unsafe { EnvoyBuffer::new_from_raw(result.ptr as *const u8, result.length) })

    } else {

      None

    }

  }

  /// Get the trace ID.

  ///

  /// Note: This is not currently supported and always returns `None`.

  /// The tracing span interface does not expose trace IDs in a way that

  /// allows zero-copy access.

  pub fn get_trace_id(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_trace_id)

  }

  /// Get the span ID.

  ///

  /// Note: This is not currently supported and always returns `None`.

  /// The tracing span interface does not expose span IDs in a way that

  /// allows zero-copy access.

  pub fn get_span_id(&self) -> Option<EnvoyBuffer<'_>> {

    self.get_envoy_buffer(abi::envoy_dynamic_module_callback_access_logger_get_span_id)

  }

  /// Get the number of headers of the specified type.

  ///

  /// The supported header types are `RequestHeader`, `ResponseHeader`, and `ResponseTrailer`.

  pub fn get_headers_count(

    &self,

    header_type: abi::envoy_dynamic_module_type_http_header_type,

  ) -> usize {

    unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_headers_size(self.envoy_ptr, header_type)

    }

  }

  /// Get all headers of the specified type as key-value `EnvoyBuffer` pairs.

  ///

  /// The supported header types are `RequestHeader`, `ResponseHeader`, and `ResponseTrailer`.

  /// Returns an empty vector if the header map is not available.

  pub fn get_all_headers(

    &self,

    header_type: abi::envoy_dynamic_module_type_http_header_type,

  ) -> Vec<(EnvoyBuffer<'_>, EnvoyBuffer<'_>)> {

    let count = self.get_headers_count(header_type);

    if count == 0 {

      return Vec::new();

    }

    let mut headers = vec![

      abi::envoy_dynamic_module_type_envoy_http_header {

        key_ptr: ptr::null_mut(),

        key_length: 0,

        value_ptr: ptr::null_mut(),

        value_length: 0,

      };

      count

    ];

    let success = unsafe {

      abi::envoy_dynamic_module_callback_access_logger_get_headers(

        self.envoy_ptr,

        header_type,

        headers.as_mut_ptr(),

      )

    };

    if !success {

      return Vec::new();

    }

    headers

      .iter()

      .map(|h| unsafe {

        (

          EnvoyBuffer::new_from_raw(h.key_ptr as *const u8, h.key_length),

          EnvoyBuffer::new_from_raw(h.value_ptr as *const u8, h.value_length),

        )

      })

      .collect()

  }

  /// Helper to retrieve an `EnvoyBuffer` from an ABI callback.

  fn get_envoy_buffer(

    &self,

    callback: unsafe extern "C" fn(

      *mut c_void,

      *mut abi::envoy_dynamic_module_type_envoy_buffer,

    ) -> bool,

  ) -> Option<EnvoyBuffer<'_>> {

    let mut buffer = abi::envoy_dynamic_module_type_envoy_buffer {

      ptr: ptr::null_mut(),

      length: 0,

    };

    if unsafe { callback(self.envoy_ptr, &mut buffer) } {

      Some(unsafe { EnvoyBuffer::new_from_raw(buffer.ptr as *const u8, buffer.length) })

    } else {

      None

    }

  }

  /// Helper to retrieve a list of SAN buffers from size + data ABI callbacks.

  fn get_san_list(

    &self,

    size_cb: unsafe extern "C" fn(*mut c_void) -> usize,

    data_cb: unsafe extern "C" fn(

      *mut c_void,

      *mut abi::envoy_dynamic_module_type_envoy_buffer,

    ) -> bool,

  ) -> Vec<EnvoyBuffer<'_>> {

    let count = unsafe { size_cb(self.envoy_ptr) };

    if count == 0 {

      return Vec::new();

    }

    let mut buffers = vec![

      abi::envoy_dynamic_module_type_envoy_buffer {

        ptr: ptr::null_mut(),

        length: 0,

      };

      count

    ];

    if !unsafe { data_cb(self.envoy_ptr, buffers.as_mut_ptr()) } {

      return Vec::new();

    }

    buffers

      .iter()

      .filter_map(|buf| {

        if buf.ptr.is_null() || buf.length == 0 {

          None

        } else {

          Some(unsafe { EnvoyBuffer::new_from_raw(buf.ptr as *const u8, buf.length) })

        }

      })

      .collect()

  }

}

/// Macro to declare access logger entry points.

///

/// This macro generates the required C ABI functions that Envoy calls to interact with

/// the access logger implementation.

///

/// # Example

///

/// ```ignore

/// use envoy_dynamic_modules_rust_sdk::{access_log::*, declare_access_logger};

///

/// struct MyLoggerConfig {

///     format: String,

///     logs_counter: CounterHandle,

///     config_envoy_ptr: *mut std::ffi::c_void,

/// }

///

/// unsafe impl Send for MyLoggerConfig {}

/// unsafe impl Sync for MyLoggerConfig {}

///

/// impl AccessLoggerConfig for MyLoggerConfig {

///     fn new(ctx: &ConfigContext, name: &str, config: &[u8]) -> Result<Self, String> {

///         let logs_counter = ctx.define_counter("logs_total")

///             .ok_or("Failed to define counter")?;

///         Ok(Self {

///             format: String::from_utf8_lossy(config).to_string(),

///             logs_counter,

///             config_envoy_ptr: ctx.envoy_ptr(),

///         })

///     }

///

///     fn create_logger(&self, metrics: MetricsContext) -> Box<dyn AccessLogger> {

///         Box::new(MyLogger {

///             format: self.format.clone(),

///             logs_counter: self.logs_counter,

///             metrics,

///         })

///     }

/// }

///

/// struct MyLogger {

///     format: String,

///     logs_counter: CounterHandle,

///     metrics: MetricsContext,

/// }

///

/// impl AccessLogger for MyLogger {

///     fn log(&mut self, ctx: &LogContext) {

///         self.metrics.increment_counter(self.logs_counter, 1);

///         if let Some(code) = ctx.response_code() {

///             println!("Response: {}", code);

///         }

///     }

/// }

///

/// declare_access_logger!(MyLoggerConfig);

/// ```

#[macro_export]

macro_rules! declare_access_logger {

  ($config_type:ty) => {

    /// Wrapper that stores both the config and the envoy pointer for metrics access.

    struct AccessLoggerConfigWrapper {

      config: $config_type,

      config_envoy_ptr: *mut ::std::ffi::c_void,

    }

    unsafe impl Send for AccessLoggerConfigWrapper {}

    unsafe impl Sync for AccessLoggerConfigWrapper {}

    #[no_mangle]

    pub extern "C" fn envoy_dynamic_module_on_access_logger_config_new(

      config_envoy_ptr: *mut ::std::ffi::c_void,

      name: $crate::abi::envoy_dynamic_module_type_envoy_buffer,

      config: $crate::abi::envoy_dynamic_module_type_envoy_buffer,

    ) -> *const ::std::ffi::c_void {

      let name_str = unsafe {

        let slice = ::std::slice::from_raw_parts(name.ptr as *const u8, name.length);

        ::std::str::from_utf8(slice).unwrap_or("")

      };

      let config_bytes =

        unsafe { ::std::slice::from_raw_parts(config.ptr as *const u8, config.length) };

      let ctx = $crate::access_log::ConfigContext::new(config_envoy_ptr);

      match <$config_type as $crate::access_log::AccessLoggerConfig>::new(

        &ctx,

        name_str,

        config_bytes,

      ) {

        Ok(c) => {

          let wrapper = AccessLoggerConfigWrapper {

            config: c,

            config_envoy_ptr,

          };

          Box::into_raw(Box::new(wrapper)) as *const ::std::ffi::c_void

        },

        Err(_) => ::std::ptr::null(),

      }

    }

    #[no_mangle]

    pub extern "C" fn envoy_dynamic_module_on_access_logger_config_destroy(

      config_ptr: *const ::std::ffi::c_void,

    ) {

      unsafe {

        drop(Box::from_raw(config_ptr as *mut AccessLoggerConfigWrapper));

      }

    }

    #[no_mangle]

    pub extern "C" fn envoy_dynamic_module_on_access_logger_new(

      config_ptr: *const ::std::ffi::c_void,

      logger_envoy_ptr: *mut ::std::ffi::c_void,

    ) -> *const ::std::ffi::c_void {

      let wrapper = unsafe { &*(config_ptr as *const AccessLoggerConfigWrapper) };

      let metrics = $crate::access_log::MetricsContext::new(wrapper.config_envoy_ptr);

      let logger = wrapper.config.create_logger(metrics, logger_envoy_ptr);

      Box::into_raw(Box::new(logger)) as *const ::std::ffi::c_void

    }

    #[no_mangle]

    pub extern "C" fn envoy_dynamic_module_on_access_logger_log(

      envoy_ptr: *mut ::std::ffi::c_void,

      logger_ptr: *mut ::std::ffi::c_void,

      log_type: $crate::abi::envoy_dynamic_module_type_access_log_type,

    ) {

      let logger = unsafe { &mut *(logger_ptr as *mut Box<dyn $crate::access_log::AccessLogger>) };

      let access_log_type = $crate::access_log::AccessLogType::from_abi(log_type);

      let ctx = $crate::access_log::LogContext::new(envoy_ptr, access_log_type);

      logger.log(&ctx);

    }

    #[no_mangle]

    pub extern "C" fn envoy_dynamic_module_on_access_logger_destroy(

      logger_ptr: *mut ::std::ffi::c_void,

    ) {

      unsafe {

        drop(Box::from_raw(

          logger_ptr as *mut Box<dyn $crate::access_log::AccessLogger>,

        ));

      }

    }

    #[no_mangle]

    pub extern "C" fn envoy_dynamic_module_on_access_logger_flush(

      logger_ptr: *mut ::std::ffi::c_void,

    ) {

      let logger = unsafe { &mut *(logger_ptr as *mut Box<dyn $crate::access_log::AccessLogger>) };

      logger.flush();

    }

  };

}