v0.3.0

.gitignore

@@ -2,4 +2,7 @@
 .zig-cache/
 zig-out/
 *.log
-logs/
+logs/
+*test_*
+test*
+test_logs/*.json

CHANGELOG.md

@@ -1,10 +1,3 @@
-### Fixed
-- Fixed deadlock in file rotation when buffer limit is reached
-- Fixed memory leaks in file path handling during log rotation
-- Improved thread safety for file size tracking
-- Added proper memory cleanup for file operations
-- Enhanced error recovery during rotation failures
-
-The file handler now properly manages system resources and handles concurrent
-access more reliably. Users should see more stable behavior during high-volume
-logging with file rotation enabled.
+### Fixed v0.3.0 (February 5, 2025)
+Added new non-failing log methods for each log level. These methods do not return an error.
+fixed compilation errors to support zig 0.14-dev

build.zig.zon

@@ -10,7 +10,7 @@
 
     // This is a [Semantic Version](https://semver.org/).
     // In a future version of Zig it will be used for package deduplication.
-    .version = "0.2.0-alpha.1",
+    .version = "0.3.0",
 
     // This field is optional.
     // This is currently advisory only; Zig does not yet do anything

examples/basic_usage.zig

@@ -29,7 +29,7 @@ const OrderProcessor = struct {
         const metadata = self.createMetadata();
 
         // Log the start of order processing
-        try self.logger.log(.debug, "Starting order processing [dept={s}, order_id={d}]", .{ self.department, order_id }, metadata);
+        self.logger.debug("Starting order processing [dept={s}, order_id={d}]", .{ self.department, order_id }, metadata);
 
         // Simulate processing steps with appropriate logging
         try self.validateOrder(order_id);
@@ -99,14 +99,14 @@ pub fn main() !void {
     };
 
     // Log application startup
-    try logger.log(.info, "Application starting", .{}, base_metadata);
+    logger.info("Application starting", .{}, base_metadata);
 
     // Simulate some logging activity
-    try logger.log(.debug, "Initializing subsystems", .{}, base_metadata);
-    try logger.log(.info, "Processing started", .{}, base_metadata);
-    try logger.log(.warn, "Resource usage high", .{}, base_metadata);
+    logger.debug("Initializing subsystems", .{}, base_metadata);
+    logger.info("Processing started", .{}, base_metadata);
+    logger.warn("Resource usage high", .{}, base_metadata);
 
     // Ensure all logs are written before shutdown
     try logger.flush();
-    try logger.log(.info, "Application shutdown complete", .{}, base_metadata);
+    logger.info("Application shutdown complete", .{}, base_metadata);
 }

examples/json_logging.zig

@@ -0,0 +1,56 @@
+const std = @import("std");
+const nexlog = @import("nexlog");
+const JsonHandler = nexlog.output.json_handler.JsonHandler;
+
+pub fn main() !void {
+    // Initialize allocator
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Create a directory for testing logs if it doesn't exist
+    const log_dir = "test_logs";
+    try std.fs.cwd().makePath(log_dir);
+
+    // Get the current working directory
+    var cwd_buf: [std.fs.max_path_bytes]u8 = undefined;
+    const cwd = std.fs.cwd().realpath(".", &cwd_buf) catch unreachable;
+
+    // Construct the absolute path for the log file within the log_dir
+    const log_file_path = std.fs.path.join(allocator, &[_][]const u8{ cwd, log_dir, "app.json" }) catch unreachable;
+    defer allocator.free(log_file_path);
+
+    // Create a JSON handler
+    var json_handler = try JsonHandler.init(allocator, .{
+        .min_level = .debug,
+        .pretty_print = true, // Optional: Makes the JSON output more readable
+        .output_file = log_file_path,
+    });
+    defer json_handler.deinit();
+
+    // Create a logger
+    const logger = try nexlog.Logger.init(allocator, .{});
+    defer logger.deinit();
+
+    // Add the JSON handler to the logger
+    try logger.addHandler(json_handler.toLogHandler());
+
+    // Create some basic metadata
+    const metadata = nexlog.LogMetadata{
+        .timestamp = std.time.timestamp(),
+        .thread_id = 0, // Replace with actual thread ID in a real application
+        .file = @src().file,
+        .line = @src().line,
+        .function = @src().fn_name,
+    };
+
+    // Log some messages with different levels and optional fields
+    // Log some messages with different levels and optional fields
+    try logger.log(.info, "Application starting", .{}, metadata);
+    try logger.log(.debug, "This is a debug message", .{}, metadata);
+    try logger.log(.warn, "This is a warning message (code: {d})", .{123}, metadata);
+    try logger.log(.err, "An error occurred (code: {s})", .{"E_UNKNOWN"}, metadata);
+
+    // Ensure all logs are written before exiting
+    try logger.flush();
+}

src/core/config.zig

@@ -1,4 +1,5 @@
 const LogLevel = @import("types.zig").LogLevel;
+const format = @import("../utils/format.zig");
 
 pub const LogConfig = struct {
     min_level: LogLevel = .info,
@@ -12,4 +13,6 @@ pub const LogConfig = struct {
     buffer_size: usize = 4096,
     async_mode: bool = false,
     enable_metadata: bool = true,
+
+    format_config: ?format.FormatConfig = null,
 };

src/core/errors.zig

@@ -13,6 +13,7 @@ pub const LogError = error{
     FormattingError,
     FilterError,
     AlreadyInitialized,
+    NotInitialized,
 };
 
 pub const FileError = error{

src/core/init.zig

@@ -3,7 +3,7 @@ const logger = @import("logger.zig");
 const config = @import("config.zig");
 const errors = @import("errors.zig");
 const types = @import("types.zig");
-
+const format = @import("../utils/format.zig");
 /// Global logger state
 pub const GlobalState = struct {
     is_initialized: bool = false,
@@ -99,6 +99,10 @@ pub const LogBuilder = struct {
             },
         };
     }
+    pub fn setFormatter(self: *LogBuilder, format_config: format.FormatConfig) *LogBuilder {
+        self.config.format_config = format_config;
+        return self;
+    }
 
     pub fn setMinLevel(self: *LogBuilder, level: types.LogLevel) *LogBuilder {
         self.config.min_level = level;