nautilus_common/ffi/
logging.rs1use std::{
17 ffi::c_char,
18 ops::{Deref, DerefMut},
19};
20
21use nautilus_core::{
22 UUID4,
23 ffi::{
24 parsing::{optional_bytes_to_json, u8_as_bool},
25 string::{cstr_as_str, cstr_to_ustr, optional_cstr_to_str},
26 },
27};
28use nautilus_model::identifiers::TraderId;
29
30use crate::{
31 enums::{LogColor, LogLevel},
32 logging::{
33 headers,
34 logger::{self, LogGuard, LoggerConfig},
35 writer::FileWriterConfig,
36 },
37};
38
39#[repr(C)]
48#[allow(non_camel_case_types)]
49#[derive(Debug)]
50pub struct LogGuard_API(Box<LogGuard>);
51
52impl Deref for LogGuard_API {
53 type Target = LogGuard;
54
55 fn deref(&self) -> &Self::Target {
56 &self.0
57 }
58}
59
60impl DerefMut for LogGuard_API {
61 fn deref_mut(&mut self) -> &mut Self::Target {
62 &mut self.0
63 }
64}
65
66#[unsafe(no_mangle)]
88pub unsafe extern "C" fn logging_init(
89 trader_id: TraderId,
90 instance_id: UUID4,
91 level_stdout: LogLevel,
92 level_file: LogLevel,
93 directory_ptr: *const c_char,
94 file_name_ptr: *const c_char,
95 file_format_ptr: *const c_char,
96 component_levels_ptr: *const c_char,
97 is_colored: u8,
98 is_bypassed: u8,
99 print_config: u8,
100 log_components_only: u8,
101 max_file_size: u64,
102 max_backup_count: u32,
103) -> LogGuard_API {
104 let level_stdout = crate::logging::map_log_level_to_filter(level_stdout);
105 let level_file = crate::logging::map_log_level_to_filter(level_file);
106
107 let component_levels_json = unsafe { optional_bytes_to_json(component_levels_ptr) };
108 let component_levels = crate::logging::parse_component_levels(component_levels_json);
109
110 let config = LoggerConfig::new(
111 level_stdout,
112 level_file,
113 component_levels,
114 u8_as_bool(log_components_only),
115 u8_as_bool(is_colored),
116 u8_as_bool(print_config),
117 );
118
119 let file_rotate = if max_file_size > 0 {
121 Some((max_file_size, max_backup_count))
122 } else {
123 None
124 };
125
126 let directory = unsafe { optional_cstr_to_str(directory_ptr).map(ToString::to_string) };
127 let file_name = unsafe { optional_cstr_to_str(file_name_ptr).map(ToString::to_string) };
128 let file_format = unsafe { optional_cstr_to_str(file_format_ptr).map(ToString::to_string) };
129
130 let file_config = FileWriterConfig::new(directory, file_name, file_format, file_rotate);
131
132 if u8_as_bool(is_bypassed) {
133 crate::logging::logging_set_bypass();
134 }
135
136 LogGuard_API(Box::new(
137 crate::logging::init_logging(trader_id, instance_id, config, file_config).unwrap(),
138 ))
139}
140
141#[unsafe(no_mangle)]
149pub unsafe extern "C" fn logger_log(
150 level: LogLevel,
151 color: LogColor,
152 component_ptr: *const c_char,
153 message_ptr: *const c_char,
154) {
155 let component = unsafe { cstr_to_ustr(component_ptr) };
156 let message = unsafe { cstr_as_str(message_ptr) };
157
158 logger::log(level, color, component, message);
159}
160
161#[unsafe(no_mangle)]
169pub unsafe extern "C" fn logging_log_header(
170 trader_id: TraderId,
171 machine_id_ptr: *const c_char,
172 instance_id: UUID4,
173 component_ptr: *const c_char,
174) {
175 let component = unsafe { cstr_to_ustr(component_ptr) };
176 let machine_id = unsafe { cstr_as_str(machine_id_ptr) };
177 headers::log_header(trader_id, machine_id, instance_id, component);
178}
179
180#[unsafe(no_mangle)]
186pub unsafe extern "C" fn logging_log_sysinfo(component_ptr: *const c_char) {
187 let component = unsafe { cstr_to_ustr(component_ptr) };
188 headers::log_sysinfo(component);
189}
190
191#[unsafe(no_mangle)]
193pub extern "C" fn logger_flush() {
194 log::logger().flush();
195}
196
197#[unsafe(no_mangle)]
199pub extern "C" fn logger_drop(log_guard: LogGuard_API) {
200 drop(log_guard);
201}
202
203#[unsafe(no_mangle)]
204pub extern "C" fn logging_is_initialized() -> u8 {
205 u8::from(crate::logging::logging_is_initialized())
206}
207
208#[unsafe(no_mangle)]
209pub extern "C" fn logging_set_bypass() {
210 crate::logging::logging_set_bypass();
211}
212
213#[unsafe(no_mangle)]
214pub extern "C" fn logging_shutdown() {
215 crate::logging::logging_shutdown();
216}
217
218#[unsafe(no_mangle)]
219pub extern "C" fn logging_is_colored() -> u8 {
220 u8::from(crate::logging::logging_is_colored())
221}
222
223#[unsafe(no_mangle)]
224pub extern "C" fn logging_clock_set_realtime_mode() {
225 crate::logging::logging_clock_set_realtime_mode();
226}
227
228#[unsafe(no_mangle)]
229pub extern "C" fn logging_clock_set_static_mode() {
230 crate::logging::logging_clock_set_static_mode();
231}
232
233#[unsafe(no_mangle)]
234pub extern "C" fn logging_clock_set_static_time(time_ns: u64) {
235 crate::logging::logging_clock_set_static_time(time_ns);
236}