macros.rs 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202
  1. /// Logs a message at the error level.
  2. ///
  3. /// # Examples
  4. ///
  5. /// ```no_run
  6. /// # let ctx = ();
  7. /// # let err_code = -1;
  8. /// use aya_log_ebpf::error;
  9. ///
  10. /// error!(&ctx, "Error redirecting packet: {}", err_code);
  11. /// error!(&ctx, target: "ingress", "Error redirecting packet: {}", err_code);
  12. /// ```
  13. #[macro_export]
  14. macro_rules! error {
  15. ($ctx:expr, target: $target:expr, $($arg:tt)+) => (
  16. $crate::log!($ctx, target: $target, $crate::Level::Error, $($arg)+)
  17. );
  18. ($ctx:expr, $($arg:tt)+) => (
  19. $crate::log!($ctx, $crate::Level::Error, $($arg)+)
  20. )
  21. }
  22. /// Logs a message at the warn level.
  23. ///
  24. /// # Examples
  25. ///
  26. /// ```
  27. /// use aya_log_ebpf::warn;
  28. ///
  29. /// # fn main() {
  30. /// let warn_description = "Invalid Input";
  31. ///
  32. /// warn!("Warning! {}!", warn_description);
  33. /// warn!(target: "input_events", "App received warning: {}", warn_description);
  34. /// # }
  35. /// ```
  36. #[macro_export]
  37. macro_rules! warn {
  38. ($ctx:expr, target: $target:expr, $($arg:tt)+) => (
  39. $crate::log!($ctx, target: $target, $crate::Level::Warn, $($arg)+)
  40. );
  41. ($ctx:expr, $($arg:tt)+) => (
  42. $crate::log!($ctx, $crate::Level::Warn, $($arg)+)
  43. )
  44. }
  45. /// Logs a message at the info level.
  46. ///
  47. /// # Examples
  48. ///
  49. /// ```edition2018
  50. /// use log::info;
  51. ///
  52. /// # fn main() {
  53. /// # struct Connection { port: u32, speed: u32 }
  54. /// let conn_info = Connection { port: 40, speed: 3 };
  55. ///
  56. /// info!("Connected to port {} at {} Mb/s", conn_info.port, conn_info.speed);
  57. /// info!(target: "connection_events", "Successfull connection, port: {}, speed: {}",
  58. /// conn_info.port, conn_info.speed);
  59. /// # }
  60. /// ```
  61. #[macro_export]
  62. macro_rules! info {
  63. ($ctx:expr, target: $target:expr, $($arg:tt)+) => (
  64. $crate::log!($ctx, target: $target, $crate::Level::Info, $($arg)+)
  65. );
  66. ($ctx:expr, $($arg:tt)+) => (
  67. $crate::log!($ctx, $crate::Level::Info, $($arg)+)
  68. )
  69. }
  70. /// Logs a message at the debug level.
  71. ///
  72. /// # Examples
  73. ///
  74. /// ```edition2018
  75. /// use log::debug;
  76. ///
  77. /// # fn main() {
  78. /// # struct Position { x: i64, y: i64 }
  79. /// let pos = Position { x: 3.234, y: -1223 };
  80. ///
  81. /// debug!("New position: x: {}, y: {}", pos.x, pos.y);
  82. /// debug!(target: "app_events", "New position: x: {}, y: {}", pos.x, pos.y);
  83. /// # }
  84. /// ```
  85. #[macro_export]
  86. macro_rules! debug {
  87. ($ctx:expr, target: $target:expr, $($arg:tt)+) => (
  88. $crate::log!($ctx, target: $target, $crate::Level::Debug, $($arg)+)
  89. );
  90. ($ctx:expr, $($arg:tt)+) => (
  91. $crate::log!($ctx, $crate::Level::Debug, $($arg)+)
  92. )
  93. }
  94. /// Logs a message at the trace level.
  95. ///
  96. /// # Examples
  97. ///
  98. /// ```edition2018
  99. /// use log::trace;
  100. ///
  101. /// # fn main() {
  102. /// # struct Position { x: i64, y: i64 }
  103. /// let pos = Position { x: 3234, y: -1223 };
  104. ///
  105. /// trace!("Position is: x: {}, y: {}", pos.x, pos.y);
  106. /// trace!(target: "app_events", "x is {} and y is {}",
  107. /// if pos.x >= 0 { "positive" } else { "negative" },
  108. /// if pos.y >= 0 { "positive" } else { "negative" });
  109. /// # }
  110. /// ```
  111. #[macro_export]
  112. macro_rules! trace {
  113. ($ctx:expr, target: $target:expr, $($arg:tt)+) => (
  114. $crate::log!($ctx, target: $target, $crate::Level::Trace, $($arg)+)
  115. );
  116. ($ctx:expr, $($arg:tt)+) => (
  117. $crate::log!($ctx, $crate::Level::Trace, $($arg)+)
  118. )
  119. }
  120. // /// Determines if a message logged at the specified level in that module will
  121. // /// be logged.
  122. // ///
  123. // /// This can be used to avoid expensive computation of log message arguments if
  124. // /// the message would be ignored anyway.
  125. // ///
  126. // /// # Examples
  127. // ///
  128. // /// ```edition2018
  129. // /// use log::Level::Debug;
  130. // /// use log::{debug, log_enabled};
  131. // ///
  132. // /// # fn foo() {
  133. // /// if log_enabled!(Debug) {
  134. // /// let data = expensive_call();
  135. // /// debug!("expensive debug data: {} {}", data.x, data.y);
  136. // /// }
  137. // /// if log_enabled!(target: "Global", Debug) {
  138. // /// let data = expensive_call();
  139. // /// debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y);
  140. // /// }
  141. // /// # }
  142. // /// # struct Data { x: u32, y: u32 }
  143. // /// # fn expensive_call() -> Data { Data { x: 0, y: 0 } }
  144. // /// # fn main() {}
  145. // /// ```
  146. // macro_rules! log_enabled {
  147. // (target: $target:expr, $lvl:expr) => {{
  148. // let lvl = $lvl;
  149. // lvl <= $crate::STATIC_MAX_LEVEL
  150. // }};
  151. // ($lvl:expr) => {
  152. // log_enabled!(target: __log_module_path!(), $lvl)
  153. // };
  154. // }
  155. /// Log a message at the given level.
  156. ///
  157. /// This macro will generically log with the specified `Level` and `format!`
  158. /// based argument list.
  159. ///
  160. /// # Examples
  161. ///
  162. /// ```edition2018
  163. /// use log::{log, Level};
  164. ///
  165. /// # fn main() {
  166. /// let data = (42, "Forty-two");
  167. /// let private_data = "private";
  168. ///
  169. /// log!(Level::Error, "Received errors: {}, {}", data.0, data.1);
  170. /// log!(target: "app_events", Level::Warn, "App warning: {}, {}, {}",
  171. /// data.0, data.1, private_data);
  172. /// # }
  173. /// ```
  174. #[macro_export]
  175. macro_rules! log {
  176. ($ctx:expr, target: $target:expr, $lvl:expr, $($arg:tt)+) => ({
  177. if let Some(buf) = unsafe { $crate::AYA_LOG_BUF.get_mut(0) } {
  178. if let Ok(header_len) = $crate::write_record_header(&mut buf.buf, module_path!(), $lvl, module_path!(), file!(), line!()) {
  179. if let Ok(message_len) = $crate::write_record_message!(&mut buf.buf[header_len..], $($arg)+) {
  180. let _ = unsafe { $crate::AYA_LOGS.output($ctx, buf, header_len + message_len) };
  181. };
  182. }
  183. }
  184. });
  185. ($ctx:expr, $lvl:expr, $($arg:tt)+) => ($crate::log!($ctx, target: __log_module_path!(), $lvl, $($arg)+))
  186. }
  187. #[doc(hidden)]
  188. #[macro_export]
  189. macro_rules! write_record_message {
  190. ($buf:expr, $($arg:tt)+) => {{
  191. use aya_log_ebpf::ufmt;
  192. let mut writer = $crate::LogBufWriter::new($buf);
  193. aya_log_ebpf::ufmt::uwrite!(writer, $($arg)+).map(|_| writer.finish())
  194. }}
  195. }