LittyLogs.File 0.1.0-dev

litty-logs 🔥

yo your .NET logs are giving corporate dystopia energy rn and thats not it bestie. litty-logs fully rewrites all them boring built-in framework messages into gen alpha slang while also blessing your terminal with emojis and ANSI colors no cap

before (deadass boring) 💀

info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5000
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Content root path: /app

after (absolutely bussin) 🔥

[🔥 info] [2026-02-18T21:45:00.420Z] [Lifetime] we vibing on http://localhost:5000 fr fr 🎧
[🔥 info] [2026-02-18T21:45:00.421Z] [Lifetime] app is bussin and ready to slay bestie 💅 yeet Ctrl+C to dip out no cap
[🔥 info] [2026-02-18T21:45:00.421Z] [Lifetime] content root living at /app bestie 📁

installation

dotnet add package LittyLogs

# for xUnit test output (optional, separate package)
dotnet add package LittyLogs.Xunit

# for file sink with rotation and gzip compression (optional, separate package)
dotnet add package LittyLogs.File

# for the CLI tool that litty-fies build and test output
dotnet tool install --global LittyLogs.Tool

usage — one line thats it thats the tweet

web api

using LittyLogs;

var builder = WebApplication.CreateBuilder(args);
builder.Logging.AddLittyLogs(); // thats it bestie 🔥
var app = builder.Build();
app.Run();

hosted service / background worker

using LittyLogs;

var host = Host.CreateDefaultBuilder(args)
    .ConfigureLogging(logging => logging.AddLittyLogs())
    .ConfigureServices(services => services.AddHostedService<MyService>())
    .Build();

await host.RunAsync();

console script (the ten-liner speedrun)

using LittyLogs;
using Microsoft.Extensions.Logging;

using var factory = LoggerFactory.Create(logging =>
{
    logging.SetMinimumLevel(LogLevel.Trace);
    logging.AddLittyLogs();
});

var logger = factory.CreateLogger("MyScript");
logger.LogInformation("we in here bestie 🔥");

xUnit tests

using LittyLogs.Xunit;
using Xunit;
using Xunit.Abstractions;

public class MyTests
{
    private readonly ILogger<MyTests> _logger;

    public MyTests(ITestOutputHelper output)
    {
        // one line to litty-fy your test output bestie 💅
        _logger = output.CreateLittyLogger<MyTests>();
    }

    [Fact]
    public void MyTest()
    {
        _logger.LogInformation("this shows up litty-fied in test output 🔥");
    }
}

JSON structured logging — for when machines need to eat too 🍽️

same litty rewrites and emojis, but as valid JSON. your log aggregator is gonna love this no cap

using LittyLogs;

var builder = WebApplication.CreateBuilder(args);
builder.Logging.AddLittyJsonLogs(); // structured JSON with emojis bestie 🔥
var app = builder.Build();
app.Run();

output:

{"timestamp":"2026-02-19T10:45:00.420Z","level":"info","emoji":"🔥","category":"Lifetime","message":"app is bussin and ready to slay bestie 💅 yeet Ctrl+C to dip out no cap"}

emojis in JSON? absolutely bussin — JSON is UTF-8 native so every parser on earth handles it perfectly 🏆

file sink — yeet logs to disk with rotation and compression 📁

using LittyLogs.File;

var builder = WebApplication.CreateBuilder(args);
builder.Logging.AddLittyFileLogs(opts =>
{
    opts.FilePath = "logs/app.log";
    opts.OutputFormat = LittyFileOutputFormat.Text;  // or Json for structured output
    opts.RollingInterval = LittyRollingInterval.Daily;
    opts.MaxFileSizeBytes = 10 * 1024 * 1024;        // 10MB then rotate
    opts.CompressionMode = LittyCompressionMode.Gzip; // compress rotated files 🗜️
});
var app = builder.Build();
app.Run();

features that go hard:

• async I/O — Channel<string> based, your app thread never blocks on disk writes 👑
• text or JSON — human-readable or machine-parseable, your choice bestie
• size + time rotation — daily, hourly, or size-based. rotated files get timestamps in the name
• gzip compression — old rotated files auto-compress to .gz, active file stays uncompressed
• startup safeguard — never auto-rotates on startup, only rotates before writing the next entry 🔒
• no ANSI codes — files never get terminal escape chars, thats cursed 💀

what gets litty-fied

all the boring framework messages you see every dotnet run:

plus hosting lifecycle, endpoint routing, and more fr fr

log level emojis

options — configure the vibe

builder.Logging.AddLittyLogs(options =>
{
    options.RewriteMessages = true;     // rewrite framework messages (default: true, thats the whole point)
    options.UseColors = true;           // ANSI colors (default: true)
    options.ShortenCategories = true;   // yeet namespace bloat (default: true)
    options.UseUtcTimestamp = true;     // UTC timestamps (default: true, international rizz)
    options.TimestampFormat = "yyyy-MM-ddTHH:mm:ss.fffK"; // ISO 8601 with milliseconds (default)
    options.TimestampFirst = false;     // false = RFC 5424 (level first), true = observability style (timestamp first)
});

dotnet litty CLI tool — litty-fy your build and test output 🧪

your app logs are litty but dotnet build and dotnet test output is still giving corporate energy? install the tool and never look at boring terminal output again no cap

# install the tool
dotnet tool install --global LittyLogs.Tool

# litty-fy your test output (auto-shows ITestOutputHelper output too)
dotnet litty test

# litty-fy your build output
dotnet litty build

# all args pass through to the underlying dotnet command
dotnet litty test --filter "FullyQualifiedName~MyTests"
dotnet litty build -c Release

before (boring test output) 💀

Passed!  - Failed:     0, Passed:    66, Skipped:     0, Total:    66, Duration: 80 ms - LittyLogs.Tests.dll (net10.0)

after (bussin test output) 🔥

  [xUnit.net] scouting for tests in LittyLogs.Tests 🔍
  [xUnit.net] found the squad in LittyLogs.Tests 📋
  [xUnit.net] lets gooo LittyLogs.Tests is cooking 🔥
  ✅ LittyLogs.Tests.MyTest.SomeTest [26 ms]
  [xUnit.net] LittyLogs.Tests absolutely ate no crumbs 💅

  all tests ate and left no crumbs 🏆
  total vibes checked: 66
  ate: 66 ✅
  cooked in 0.5 Seconds ⏱️

your own logs stay untouched

litty-logs only rewrites known framework messages. your custom log messages pass through with the bussin formatting (emojis, colors, short categories) but the actual message text stays exactly how you wrote it no cap

logger.LogInformation("my custom message stays exactly like this");
// output: [🔥 info] [2026-02-18T21:45:00.420Z] [MyService] my custom message stays exactly like this

examples

six example projects in examples/ so you can see litty-logs in every scenario:

development — for the contributing besties 🛠️

just recipes

this project uses just as the task runner. here are the vibes:

shell completions

tab-complete just example <tab> to see all available examples. works with zsh and bash:

# auto-install to your shell rc file
just setup-completions

# or source manually
source completions/just.zsh   # zsh
source completions/just.bash  # bash

versioning

version lives in one place: Directory.Build.props. all four packages inherit from it. we use gitflow via the git flow CLI — main is production, develop is the integration branch, releases and hotfixes get their own branches 🔥

release flow (gitflow)

# from develop — full gitflow ceremony (bump, release branch, merge, tag, cleanup)
just release patch    # 0.1.0 → 0.1.1
just release minor    # 0.1.0 → 0.2.0
just release major    # 0.1.0 → 1.0.0

# or release the current version without bumping (e.g. first release)
just release-current

# push everything to trigger the CI/CD pipeline
git push origin develop main v0.1.1

hotfix flow

# from main — start a hotfix when something is bricked in prod
just hotfix patch

# make your fix, commit it, then finish
just hotfix-finish

# push everything
git push origin develop main v0.1.1

CI/CD

forgejo actions handles the pipeline on a self-hosted runner:

• CI — builds, tests (with litty output 🔥), and packs on every push/PR to develop and main
• Release — triggered by v* tags. builds, tests, packs, pushes to nuget.org, and creates releases on both Forgejo and GitHub with .nupkg assets attached 🔥

see docs/runner-setup.md for runner setup instructions no cap

license

MIT — share the vibes bestie ✌️