use log to json

Author: Mzack9999

.gitignore

@@ -1,2 +1,3 @@
 *.exe
 cmd/simplehttpserver/simplehttpserver
+simplehttpserver

internal/runner/options.go

@@ -40,6 +40,7 @@ type Options struct {
 	Python          bool
 	CORS            bool
 	HTTPHeaders     HTTPHeaders
+	JSONLogFile     string
 }
 
 // ParseOptions parses the command line options for application
@@ -77,6 +78,7 @@ func ParseOptions() *Options {
 		flagSet.BoolVar(&options.Python, "py", false, "Emulate Python Style"),
 		flagSet.BoolVar(&options.CORS, "cors", false, "Enable Cross-Origin Resource Sharing (CORS)"),
 		flagSet.Var(&options.HTTPHeaders, "header", "Add HTTP Response Header (name: value), can be used multiple times"),
+		flagSet.StringVar(&options.JSONLogFile, "json-log", "", "JSON log file path for request logging"),
 	)
 
 	flagSet.CreateGroup("debug", "Debug",

internal/runner/runner.go

@@ -76,6 +76,7 @@ func New(options *Options) (*Runner, error) {
 		Python:            r.options.Python,
 		CORS:              r.options.CORS,
 		HTTPHeaders:       r.options.HTTPHeaders,
+		JSONLogFile:       r.options.JSONLogFile,
 	})
 	if err != nil {
 		return nil, err

pkg/httpserver/httpserver.go

@@ -31,12 +31,14 @@ type Options struct {
 	Python            bool
 	CORS              bool
 	HTTPHeaders       []HTTPHeader
+	JSONLogFile       string
 }
 
 // HTTPServer instance
 type HTTPServer struct {
-	options *Options
-	layers  http.Handler
+	options    *Options
+	layers     http.Handler
+	jsonLogger *JSONLogger
 }
 
 // LayerHandler is the interface of all layer funcs
@@ -48,6 +50,15 @@ func New(options *Options) (*HTTPServer, error) {
 	EnableUpload = options.EnableUpload
 	EnableVerbose = options.Verbose
 	EnableLogUA = options.LogUA
+
+	// Initialize JSON logger if specified
+	if options.JSONLogFile != "" {
+		jsonLogger, err := NewJSONLogger(options.JSONLogFile)
+		if err != nil {
+			return nil, err
+		}
+		h.jsonLogger = jsonLogger
+	}
 	folder, err := filepath.Abs(options.Folder)
 	if err != nil {
 		return nil, err
@@ -129,5 +140,8 @@ func (t *HTTPServer) ListenAndServeTLS() error {
 
 // Close the service
 func (t *HTTPServer) Close() error {
+	if t.jsonLogger != nil {
+		return t.jsonLogger.Close()
+	}
 	return nil
 }

pkg/httpserver/jsonlogger.go

@@ -0,0 +1,93 @@
+package httpserver
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"sync"
+	"time"
+)
+
+// JSONLogEntry represents a single HTTP request log entry in JSON format
+type JSONLogEntry struct {
+	Timestamp    string            `json:"timestamp"`
+	RemoteAddr   string            `json:"remote_addr"`
+	Method       string            `json:"method"`
+	URL          string            `json:"url"`
+	Proto        string            `json:"proto"`
+	StatusCode   int               `json:"status_code"`
+	Size         int               `json:"size"`
+	UserAgent    string            `json:"user_agent,omitempty"`
+	Headers      map[string]string `json:"headers,omitempty"`
+	RequestBody  string            `json:"request_body,omitempty"`
+	ResponseBody string            `json:"response_body,omitempty"`
+}
+
+// JSONLogger handles writing JSON log entries to a file
+type JSONLogger struct {
+	file   *os.File
+	mutex  sync.Mutex
+	enable bool
+}
+
+// NewJSONLogger creates a new JSON logger instance
+func NewJSONLogger(filePath string) (*JSONLogger, error) {
+	if filePath == "" {
+		return &JSONLogger{enable: false}, nil
+	}
+
+	file, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open JSON log file: %w", err)
+	}
+
+	return &JSONLogger{
+		file:   file,
+		enable: true,
+	}, nil
+}
+
+// LogRequest logs an HTTP request to the JSON file
+func (jl *JSONLogger) LogRequest(r *http.Request, statusCode, size int, userAgent string, headers map[string]string, requestBody, responseBody string) error {
+	if !jl.enable {
+		return nil
+	}
+
+	entry := JSONLogEntry{
+		Timestamp:    time.Now().Format(time.RFC3339),
+		RemoteAddr:   r.RemoteAddr,
+		Method:       r.Method,
+		URL:          r.URL.String(),
+		Proto:        r.Proto,
+		StatusCode:   statusCode,
+		Size:         size,
+		UserAgent:    userAgent,
+		Headers:      headers,
+		RequestBody:  requestBody,
+		ResponseBody: responseBody,
+	}
+
+	jl.mutex.Lock()
+	defer jl.mutex.Unlock()
+
+	jsonData, err := json.Marshal(entry)
+	if err != nil {
+		return fmt.Errorf("failed to marshal JSON log entry: %w", err)
+	}
+
+	_, err = jl.file.Write(append(jsonData, '\n'))
+	if err != nil {
+		return fmt.Errorf("failed to write JSON log entry: %w", err)
+	}
+
+	return nil
+}
+
+// Close closes the JSON log file
+func (jl *JSONLogger) Close() error {
+	if jl.file != nil {
+		return jl.file.Close()
+	}
+	return nil
+}

pkg/httpserver/loglayer.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 	"net/http/httputil"
 	"time"
+
 	"github.com/projectdiscovery/gologger"
 )
 
@@ -30,6 +31,31 @@ func (t *HTTPServer) loglayer(handler http.Handler) http.Handler {
 		lrw := newLoggingResponseWriter(w, t.options.MaxDumpBodySize)
 		handler.ServeHTTP(lrw, r)
 
+		// Log to JSON file if JSON logger is enabled
+		if t.jsonLogger != nil {
+			// Extract headers
+			headers := make(map[string]string)
+			for name, values := range r.Header {
+				if len(values) > 0 {
+					headers[name] = values[0]
+				}
+			}
+
+			// Extract request body from fullRequest
+			requestBody := ""
+			if len(fullRequest) > 0 {
+				// Find the double CRLF that separates headers from body
+				bodyStart := bytes.Index(fullRequest, []byte("\r\n\r\n"))
+				if bodyStart != -1 && bodyStart+4 < len(fullRequest) {
+					requestBody = string(fullRequest[bodyStart+4:])
+				}
+			}
+
+			// Log to JSON file
+			_ = t.jsonLogger.LogRequest(r, lrw.statusCode, lrw.Size, r.UserAgent(), headers, requestBody, string(lrw.Data))
+		}
+
+		// Continue with existing console logging
 		if EnableVerbose {
 			headers := new(bytes.Buffer)
 			lrw.Header().Write(headers) //nolint