feat: Firetail Interceptor. Add tests to support correct disabling

Author: monowai

.gitignore

@@ -100,4 +100,5 @@ project.xcworkspace
 version.yml
 
 #Andorid
-local.properties
+local.properties
+/examples/src/main/resources/application-local.yml

examples/src/main/resources/application.properties

@@ -0,0 +1,10 @@
+firetail:
+  apikey: "set-your-ft-api-key-here"
+  url: "https://your.sandbox.firetail.app"
+
+logging:
+  firetail:
+    enabled: true
+springdoc:
+    api-docs:
+      path: /api-docs

examples/src/main/resources/application.yml

@@ -8,6 +8,8 @@ class Constants {
         const val RESPONSE_TIME = "X-Response-Time"
         const val RESPONSE_STATUS = "X-Response-Status"
         const val AUDIT = "audit"
+
+        // const val FIRETAIL_APPENDER_NAME = "FIRETAIL"
         val empty = ByteArray(0)
     }
 }

src/main/kotlin/io/firetail/logging/base/Constants.kt

@@ -1,27 +1,53 @@
 package io.firetail.logging.base
 
 import io.firetail.logging.servlet.FiretailFilter
-import io.firetail.logging.util.LogContext
+import io.firetail.logging.servlet.FiretailHeaderInterceptor
+import io.firetail.logging.util.FiretailLogContext
 import io.firetail.logging.util.StringUtils
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.beans.factory.annotation.Value
-import org.springframework.context.ApplicationContext
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty
+import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
 import org.springframework.context.annotation.Import
+import org.springframework.web.client.RestTemplate
 
 @Configuration
 @Import(
-    FiretailLogger::class,
     StringUtils::class,
-    LogContext::class,
     FiretailFilter::class,
 )
+@ConditionalOnProperty("logging.firetail.enabled")
 class FiretailConfig @Autowired constructor(
     @Value("\${firetail.ignorePatterns:#null}")
     val ignorePatterns: String?,
     @Value("\${firetail.logHeaders:false}")
     val logHeaders: Boolean = false,
+    @Value("\${firetail.url:http://localhost:8500}")
+    val url: String,
+    @Value("\${firetail.apiKey:not-defined}")
+    val apiKey: String,
 ) {
-    @Autowired
-    lateinit var context: ApplicationContext
+
+    val key = "X-FT-API-KEY"
+
+    @Bean
+    fun firetailLogContext(): FiretailLogContext = FiretailLogContext()
+
+    @Bean
+    fun firetailTemplate(): FiretailTemplate {
+        return FiretailTemplate(this)
+    }
+
+    @Bean
+    fun firetailHeaderInterceptor(): FiretailHeaderInterceptor = FiretailHeaderInterceptor()
+
+    @Bean
+    fun wireInterceptor(
+        restTemplate: RestTemplate,
+        firetailHeaderInterceptor: FiretailHeaderInterceptor,
+    ): RestTemplate {
+        restTemplate.interceptors.add(firetailHeaderInterceptor)
+        return restTemplate
+    }
 }

src/main/kotlin/io/firetail/logging/base/FiretailConfig.kt

@@ -0,0 +1,32 @@
+package io.firetail.logging.base
+
+import java.time.LocalDateTime
+import java.time.ZoneOffset
+
+data class FireTailLog(
+    val version: String = "1.0.0-alpha",
+    val dateCreated: Long = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC),
+    val executionTime: Int,
+    val request: Request,
+    val response: Response,
+)
+
+data class Request(
+    val headers: Headers,
+    val httpProtocol: String,
+    val method: String,
+    val body: String = "",
+    val ip: String,
+    val resource: String,
+    val uri: String,
+)
+
+data class Headers(
+    val key: Map<String, String>,
+)
+
+data class Response(
+    val statusCode: Int,
+    val body: String,
+    val headers: Headers,
+)

src/main/kotlin/io/firetail/logging/base/FiretailLogData.kt

@@ -1,17 +1,46 @@
 package io.firetail.logging.base
 
+import com.fasterxml.jackson.databind.ObjectMapper
 import io.firetail.logging.servlet.SpringRequestWrapper
 import io.firetail.logging.servlet.SpringResponseWrapper
 import io.firetail.logging.util.StringUtils
 import net.logstash.logback.argument.StructuredArguments
 import org.slf4j.LoggerFactory
-import org.springframework.stereotype.Service
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty
+import java.io.DataOutputStream
+import java.net.HttpURLConnection
+import java.net.URL
+
+@ConditionalOnProperty("logging.firetail.enabled")
+class FiretailTemplate(private val firetailConfig: FiretailConfig) {
+
+    private val uploadUrl = firetailConfig.url + "/logs/bulk"
+    private val connection = URL(uploadUrl).openConnection() as HttpURLConnection
+    private val objectMapper = ObjectMapper()
+    private val stringUtils: StringUtils = StringUtils()
+
+    companion object {
+        private val LOGGER = LoggerFactory.getLogger(this::class.java)
+    }
+
+    fun send(fireTailLog: FireTailLog) {
+        post(objectMapper.writeValueAsString(fireTailLog))
+    }
+
+    private fun post(jsonBody: String) {
+        // Set up the connection for a POST request
+        connection.requestMethod = "POST"
+        connection.doOutput = false
+        connection.setRequestProperty(firetailConfig.key, firetailConfig.apiKey)
+        connection.setRequestProperty("CONTENT-TYPE", "application/nd-json")
+
+        // Write the JSON body to the request
+        val outputStream = DataOutputStream(connection.outputStream)
+        outputStream.writeBytes(jsonBody)
+        outputStream.flush()
+        outputStream.close()
+    }
 
-@Service
-class FiretailLogger(
-    private val stringUtils: StringUtils = StringUtils(),
-    private val firetailConfig: FiretailConfig,
-) {
     fun logRequest(wrappedRequest: SpringRequestWrapper) =
         if (firetailConfig.logHeaders) {
             logWithHeaders(wrappedRequest)
@@ -82,8 +111,4 @@ class FiretailLogger(
             StructuredArguments.value(Constants.AUDIT, true),
         )
     }
-
-    companion object {
-        private val LOGGER = LoggerFactory.getLogger(this::class.java)
-    }
 }

src/main/kotlin/io/firetail/logging/base/FiretailLogger.kt renamed to src/main/kotlin/io/firetail/logging/base/FiretailTemplate.kt

@@ -0,0 +1,44 @@
+package io.firetail.logging.base
+
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.boot.context.properties.ConfigurationProperties
+import org.springframework.context.annotation.Configuration
+import org.springframework.context.annotation.Import
+
+@Configuration
+@ConfigurationProperties(prefix = "logging.logstash")
+@Import(FiretailConfig::class)
+class TcpLogger(val firetailConfig: FiretailConfig) {
+    var trustStoreLocation: String? = null
+    var trustStorePassword: String? = null
+
+    @Value("\${spring.application.name:-}")
+    lateinit var name: String
+
+//    @Bean
+//    @ConditionalOnProperty("logging.firetail.enabled")
+//    fun firetailAppender(): LogstashTcpSocketAppender {
+//        val loggerContext = LoggerFactory.getILoggerFactory() as LoggerContext
+//        val logstashTcpSocketAppender = LogstashTcpSocketAppender()
+//        logstashTcpSocketAppender.name = FIRETAIL_APPENDER_NAME
+//        logstashTcpSocketAppender.context = loggerContext
+//        logstashTcpSocketAppender.addDestination(firetailConfig.url)
+//        if (trustStoreLocation != null) {
+//            val sslConfiguration = SSLConfiguration()
+//            val factory = KeyStoreFactoryBean()
+//            factory.location = trustStoreLocation
+//            if (trustStorePassword != null) factory.password = trustStorePassword
+//            sslConfiguration.trustStore = factory
+//            logstashTcpSocketAppender.ssl = sslConfiguration
+//        }
+//        val encoder = LogstashEncoder()
+//        encoder.context = loggerContext
+//        encoder.isIncludeContext = true
+//        encoder.customFields = "{\"appname\":\"$name\"}"
+//        encoder.start()
+//        logstashTcpSocketAppender.encoder = encoder
+//        logstashTcpSocketAppender.start()
+//        loggerContext.getLogger(Logger.ROOT_LOGGER_NAME).addAppender(logstashTcpSocketAppender)
+//        return logstashTcpSocketAppender
+//    }
+}