Refactor gelf messages convert into sentry

Author: Mnwa

src/gelf/error.rs

@@ -1,6 +1,7 @@
 use std::error::Error;
 use std::fmt::{Display, Formatter, Result};
 
+/// Gelf error struct, which used to e-prints when something wrong.
 #[derive(Debug)]
 pub struct GelfError {
     message: String,

src/gelf/gelf_message_processor.rs

@@ -1,12 +1,15 @@
-use crate::gelf::gelf_reader::GelfReader;
+use crate::gelf::gelf_reader::GelfDataWrapper;
+use crate::sentry::sentry_processor::SentryEvent;
 use actix::prelude::*;
-use serde_json::Value;
 
-pub struct GelfProcessorMessage(pub GelfReader);
+/// Message, which contains parsed gelf data
+pub struct GelfProcessorMessage(pub GelfDataWrapper);
 impl Message for GelfProcessorMessage {
-    type Result = Option<Value>;
+    type Result = Option<SentryEvent>;
 }
 
+/// Simplest Gelf Processor Actor
+/// Just prints gelf message to stdio
 pub struct GelfPrinterActor;
 impl GelfPrinterActor {
     #[allow(dead_code)]
@@ -20,7 +23,7 @@ impl Actor for GelfPrinterActor {
 }
 
 impl Handler<GelfProcessorMessage> for GelfPrinterActor {
-    type Result = Option<Value>;
+    type Result = Option<SentryEvent>;
 
     fn handle(
         &mut self,

src/gelf/gelf_reader.rs

@@ -1,38 +1,36 @@
 use actix::prelude::*;
-use serde::de::Error;
+use serde::de::{Error, Unexpected};
 use serde::{Deserialize, Serialize};
-use serde_json::{Map, Result as JsonResult, Value};
+use serde_json::{Error as JsonError, Map, Result as JsonResult, Value};
+use std::str::FromStr;
 
-pub struct GelfReader {
+/// Struct, which contains gelf data
+pub struct GelfDataWrapper {
     data: GelfData,
 }
 
-impl GelfReader {
-    pub fn from_slice(buf: &[u8]) -> JsonResult<GelfReader> {
+impl GelfDataWrapper {
+    /// Create gelf data wrapper from json slice
+    pub fn from_slice(buf: &[u8]) -> JsonResult<GelfDataWrapper> {
         let data: Map<String, Value> = serde_json::from_slice(&buf)?;
 
-        let data = match to_gelf(data) {
-            Some(data) => data,
-            None => {
-                return Err(serde_json::Error::missing_field(
-                    "one of the gelf data struct",
-                ))
-            }
-        };
+        let data = to_gelf(data)?;
 
-        Ok(GelfReader { data })
+        Ok(GelfDataWrapper { data })
     }
 
+    /// print gelf data to stdio
     pub fn print(&self) {
         println!("{}", self.to_string());
     }
 
-    pub fn as_gelf(&self) -> &GelfData {
-        &self.data
+    /// Returns a GelfData of this `String`'s contents.
+    pub fn into_gelf(self) -> GelfData {
+        self.data
     }
 }
 
-impl ToString for GelfReader {
+impl ToString for GelfDataWrapper {
     fn to_string(&self) -> String {
         serde_json::to_string(&self.data).unwrap()
     }
@@ -41,7 +39,7 @@ impl ToString for GelfReader {
 pub struct GelfMessage(pub Vec<u8>);
 
 impl Message for GelfMessage {
-    type Result = JsonResult<GelfReader>;
+    type Result = JsonResult<GelfDataWrapper>;
 }
 
 pub struct GelfReaderActor;
@@ -57,50 +55,99 @@ impl Actor for GelfReaderActor {
 }
 
 impl Handler<GelfMessage> for GelfReaderActor {
-    type Result = JsonResult<GelfReader>;
+    type Result = JsonResult<GelfDataWrapper>;
 
     fn handle(&mut self, GelfMessage(msg): GelfMessage, _ctx: &mut Self::Context) -> Self::Result {
-        GelfReader::from_slice(msg.as_slice())
+        GelfDataWrapper::from_slice(msg.as_slice())
     }
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct GelfData {
     pub host: String,
-    pub level: u8,
+    pub level: GelfLevel,
     pub short_message: String,
     pub timestamp: f64,
     pub version: String,
     pub meta: Map<String, Value>,
     pub mechanism_data: Map<String, Value>,
 }
 
-fn to_gelf(data: Map<String, Value>) -> Option<GelfData> {
+fn to_gelf(data: Map<String, Value>) -> JsonResult<GelfData> {
     let mut meta = Map::new();
     let mut mechanism_data = Map::new();
     let gelf_fields: [String; 5] = [
-        "host".to_owned(),
-        "level".to_owned(),
-        "short_message".to_owned(),
-        "timestamp".to_owned(),
-        "version".to_owned(),
+        "host".to_string(),
+        "level".to_string(),
+        "short_message".to_string(),
+        "timestamp".to_string(),
+        "version".to_string(),
     ];
     data.iter().for_each(|(k, v)| {
-        let str_k = k.as_str();
-        if &str_k[..1] == "_" {
-            meta.insert(str_k[1..].to_owned(), v.to_owned());
-        } else if !gelf_fields.contains(k) {
-            mechanism_data.insert(str_k.to_owned(), v.to_owned());
-        }
+        match k.split_at(1) {
+            ("_", field) => meta.insert(field.to_string(), v.to_owned()),
+            (_, _) if !gelf_fields.contains(k) => mechanism_data.insert(k.to_owned(), v.to_owned()),
+            _ => None,
+        };
     });
 
-    Some(GelfData {
-        host: data.get("host")?.to_string(),
-        level: data.get("level")?.as_u64()? as u8,
-        short_message: data.get("short_message")?.to_string(),
-        timestamp: data.get("timestamp")?.as_f64()?,
-        version: data.get("version")?.to_string(),
+    Ok(GelfData {
+        host: data
+            .get("host")
+            .ok_or_else(|| JsonError::missing_field("host"))?
+            .to_string(),
+        level: data
+            .get("level")
+            .ok_or_else(|| JsonError::missing_field("level"))?
+            .to_string()
+            .parse::<GelfLevel>()?,
+        short_message: data
+            .get("short_message")
+            .ok_or_else(|| JsonError::missing_field("short_message"))?
+            .to_string(),
+        timestamp: data
+            .get("timestamp")
+            .ok_or_else(|| JsonError::missing_field("timestamp"))?
+            .as_f64()
+            .ok_or_else(|| JsonError::invalid_type(Unexpected::Other("timestamp"), &"u8"))?,
+        version: data
+            .get("version")
+            .ok_or_else(|| JsonError::missing_field("version"))?
+            .to_string(),
         meta,
         mechanism_data,
     })
 }
+
+#[derive(Serialize, Deserialize, Clone)]
+pub enum GelfLevel {
+    Emergency = 0,
+    Alert = 1,
+    Critical = 2,
+    Error = 3,
+    Warning = 4,
+    Notice = 5,
+    Informational = 6,
+    Debug = 7,
+}
+
+impl FromStr for GelfLevel {
+    type Err = JsonError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "0" => Ok(GelfLevel::Emergency),
+            "1" => Ok(GelfLevel::Alert),
+            "2" => Ok(GelfLevel::Critical),
+            "3" => Ok(GelfLevel::Error),
+            "4" => Ok(GelfLevel::Warning),
+            "5" => Ok(GelfLevel::Notice),
+            "6" => Ok(GelfLevel::Informational),
+            "7" => Ok(GelfLevel::Debug),
+            _ => Err(JsonError::invalid_value(
+                Unexpected::Other("level"),
+                &"integers from 0 to 7",
+            )),
+        }
+    }
+}