Touch ups

Author: neuronull

src/sinks/http/encoder.rs

@@ -18,6 +18,7 @@ pub(super) struct HttpEncoder {
 }
 
 impl HttpEncoder {
+    /// Creates a new `HttpEncoder`.
     pub(super) const fn new(encoder: Encoder<Framer>, transformer: Transformer) -> Self {
         Self {
             encoder,

src/sinks/http/request_builder.rs

@@ -1,8 +1,7 @@
 //! `RequestBuilder` implementation for the `http` sink.
 
-use std::io;
-
 use bytes::Bytes;
+use std::io;
 
 use crate::sinks::{prelude::*, util::http_service::HttpRequest};
 

src/sinks/util/http_service/request.rs

@@ -14,6 +14,7 @@ pub struct HttpRequest {
 }
 
 impl HttpRequest {
+    /// Creates a new `HttpRequest`.
     pub fn new(
         payload: Bytes,
         finalizers: EventFinalizers,

src/sinks/util/http_service/retry.rs

@@ -36,3 +36,39 @@ impl RetryLogic for HttpRetryLogic {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use bytes::Bytes;
+    use hyper::Response;
+    use vector_common::request_metadata::GroupedCountByteSize;
+
+    use super::{HttpResponse, HttpRetryLogic};
+    use crate::sinks::util::retries::RetryLogic;
+
+    #[test]
+    fn validate_retry_logic() {
+        let logic = HttpRetryLogic;
+
+        fn generate_response(code: u16) -> HttpResponse {
+            HttpResponse {
+                http_response: Response::builder().status(code).body(Bytes::new()).unwrap(),
+                events_byte_size: GroupedCountByteSize::new_untagged(),
+                raw_byte_size: 0,
+            }
+        }
+
+        assert!(logic
+            .should_retry_response(&generate_response(429))
+            .is_retryable());
+        assert!(logic
+            .should_retry_response(&generate_response(500))
+            .is_retryable());
+        assert!(logic
+            .should_retry_response(&generate_response(400))
+            .is_not_retryable());
+        assert!(logic
+            .should_retry_response(&generate_response(501))
+            .is_not_retryable());
+    }
+}

src/sinks/util/http_service/service.rs

@@ -12,8 +12,8 @@ use super::request::HttpRequest;
 /// Response type for use in the `Service` implementation of HTTP stream sinks.
 pub struct HttpResponse {
     pub(super) http_response: Response<Bytes>,
-    events_byte_size: GroupedCountByteSize,
-    raw_byte_size: usize,
+    pub(super) events_byte_size: GroupedCountByteSize,
+    pub(super) raw_byte_size: usize,
 }
 
 impl DriverResponse for HttpResponse {
@@ -34,14 +34,18 @@ impl DriverResponse for HttpResponse {
     }
 }
 
+/// Build HTTP requests for the `HttpService`.
 ///
+/// This trait exists to allow HTTP based stream sinks to utilize the common `HttpService`
+/// while being able to define sink-specific HTTP requests.
 pub trait HttpServiceRequestBuilder {
-    /// B
     fn build(&self, body: BytesMut) -> Request<Bytes>;
 }
 
 /// `Service` implementation of HTTP stream sinks.
 ///
+/// `http_request_builder` <R> must implement the `HttpServiceRequestBuilder` trait, which is
+///  used in the `Service::call()` function to handle sink-specific HTTP request building.
 #[derive(Debug, Clone)]
 pub struct HttpService<R> {
     http_request_builder: R,
@@ -50,6 +54,7 @@ pub struct HttpService<R> {
 }
 
 impl<R> HttpService<R> {
+    /// Creates a new `HttpService`.
     pub const fn new(http_request_builder: R, client: HttpClient, protocol: String) -> Self {
         Self {
             http_request_builder,