Struct AuditLogEntry

pub struct AuditLogEntry {

    pub base: BaseLogEntry,
    pub version: String,
    pub deployment_id: Option<String>,
    pub event: String,
    pub entry_type: Option<String>,
    pub api: ApiDetails,
    pub remote_host: Option<String>,
    pub user_agent: Option<String>,
    pub req_path: Option<String>,
    pub req_host: Option<String>,
    pub req_claims: Option<HashMap<String, Value>>,
    pub req_query: Option<HashMap<String, String>>,
    pub req_header: Option<HashMap<String, String>>,
    pub resp_header: Option<HashMap<String, String>>,
    pub access_key: Option<String>,
    pub parent_user: Option<String>,
    pub error: Option<String>,
}

Entry - audit entry logs AuditLogEntry is used to define the structure of an audit log entry

The AuditLogEntry structure contains the following fields:

• base - the base log entry
• version - the version of the audit log entry
• deployment_id - the deployment ID
• event - the event
• entry_type - the type of audit message
• api - the API details
• remote_host - the remote host
• user_agent - the user agent
• req_path - the request path
• req_host - the request host
• req_claims - the request claims
• req_query - the request query
• req_header - the request header
• resp_header - the response header
• access_key - the access key
• parent_user - the parent user
• error - the error

The AuditLogEntry structure contains the following methods:

• new - create a new AuditEntry with default values
• new_with_values - create a new AuditEntry with version, time, event and api details
• with_base - set the base log entry
• set_version - set the version
• set_deployment_id - set the deployment ID
• set_event - set the event
• set_entry_type - set the entry type
• set_api - set the API details
• set_remote_host - set the remote host
• set_user_agent - set the user agent
• set_req_path - set the request path
• set_req_host - set the request host
• set_req_claims - set the request claims
• set_req_query - set the request query
• set_req_header - set the request header
• set_resp_header - set the response header
• set_access_key - set the access key
• set_parent_user - set the parent user
• set_error - set the error

Example

use rustfs_obs::AuditLogEntry;
use rustfs_obs::ApiDetails;
use std::collections::HashMap;

let entry = AuditLogEntry::new()
    .set_version("1.0".to_string())
    .set_deployment_id(Some("123".to_string()))
    .set_event("event".to_string())
    .set_entry_type(Some("type".to_string()))
    .set_api(ApiDetails::new())
    .set_remote_host(Some("remote-host".to_string()))
    .set_user_agent(Some("user-agent".to_string()))
    .set_req_path(Some("req-path".to_string()))
    .set_req_host(Some("req-host".to_string()))
    .set_req_claims(Some(HashMap::new()))
    .set_req_query(Some(HashMap::new()))
    .set_req_header(Some(HashMap::new()))
    .set_resp_header(Some(HashMap::new()))
    .set_access_key(Some("access-key".to_string()))
    .set_parent_user(Some("parent-user".to_string()))
    .set_error(Some("error".to_string()));

Fields

base: BaseLogEntry

version: String

deployment_id: Option<String>

event: String

entry_type: Option<String>

api: ApiDetails

remote_host: Option<String>

user_agent: Option<String>

req_path: Option<String>

req_host: Option<String>

req_claims: Option<HashMap<String, Value>>

req_query: Option<HashMap<String, String>>

req_header: Option<HashMap<String, String>>

resp_header: Option<HashMap<String, String>>

access_key: Option<String>

parent_user: Option<String>

error: Option<String>

Implementations

impl AuditLogEntry

pub fn new() -> Self

Create a new AuditEntry with default values

pub fn new_with_values( version: String, time: DateTime<Utc>, event: String, api: ApiDetails, ) -> Self

Create a new AuditEntry with version, time, event and api details

pub fn with_base(self, base: BaseLogEntry) -> Self

Set the base log entry

pub fn set_version(self, version: String) -> Self

Set the version

pub fn set_deployment_id(self, deployment_id: Option<String>) -> Self

Set the deployment ID

pub fn set_event(self, event: String) -> Self

Set the event

pub fn set_entry_type(self, entry_type: Option<String>) -> Self

Set the entry type

pub fn set_api(self, api: ApiDetails) -> Self

Set the API details

pub fn set_remote_host(self, remote_host: Option<String>) -> Self

Set the remote host

pub fn set_user_agent(self, user_agent: Option<String>) -> Self

Set the user agent

pub fn set_req_path(self, req_path: Option<String>) -> Self

Set the request path

pub fn set_req_host(self, req_host: Option<String>) -> Self

Set the request host

pub fn set_req_claims(self, req_claims: Option<HashMap<String, Value>>) -> Self

Set the request claims

pub fn set_req_query(self, req_query: Option<HashMap<String, String>>) -> Self

Set the request query

pub fn set_req_header(self, req_header: Option<HashMap<String, String>>) -> Self

Set the request header

pub fn set_resp_header( self, resp_header: Option<HashMap<String, String>>, ) -> Self

Set the response header

pub fn set_access_key(self, access_key: Option<String>) -> Self

Set the access key

pub fn set_parent_user(self, parent_user: Option<String>) -> Self

Set the parent user

pub fn set_error(self, error: Option<String>) -> Self

Set the error

Trait Implementations

impl Clone for AuditLogEntry

fn clone(&self) -> AuditLogEntry

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AuditLogEntry

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AuditLogEntry

fn default() -> AuditLogEntry

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AuditLogEntry

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl LogRecord for AuditLogEntry

fn to_json(&self) -> String

fn get_timestamp(&self) -> DateTime<Utc>

impl Serialize for AuditLogEntry

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.