ArgusLogs

The problem

When production breaks, logs rarely tell the whole story.

A customer reports an error. You search the logs.
You see a status code or generic message—but not the SQL that ran, the outbound HTTP call, or the parameters that mattered.
So you reproduce locally, add more logging, and wait for the next deploy before you can learn anything useful.

ArgusLogs captures SQL, HTTP, parameters, and exceptions automatically—the context you needed was already in production.

Traditional logging vs ArgusLogs

Stop writing logs for problems you haven't discovered yet.

Traditional logging

Developer adds LogInformation calls across services
Issue hits production
Logs show a status code—not SQL, HTTP, or parameters
Reproduce locally and ship more logging in the next deploy

The ArgusLogs way

Request runs in production
SQL, HTTP, parameters, and exceptions captured automatically
Search by trace ID or user in ArgusLogs.UI
Understand what failed from correlated context
Fix from evidence—without reproducing the incident

Don't predict which information you'll need later.

Why Argus

See what actually happened inside your application.

Every production request leaves a full trail automatically—so you debug from evidence, not guesswork.

Understand

Know what ran in production—the entry point, downstream work, and where it failed—in one correlated timeline.

Investigate

Find the failing request by user, route, or trace ID and follow the evidence—without reproducing the incident or attaching a debugger to production.

Resolve

Fix from facts captured at failure time instead of guessing what to log before the next deploy.

Capabilities

The context behind every production request.

Seven capture domains—from the incoming request to nested SQL and HTTP—so you investigate production failures with evidence, not guesswork.

ArgusLogs UI detail view showing method trace and parameters — Drill into method traces, parameters, and SQL from the embedded dashboard.

Request Context

Captures: Incoming API routes, HTTP method, status codes, and request timing where NetworkTracker is configured.
Why it matters: Know which endpoint failed and how long it took—without reproducing the call locally.

Example POST /api/orders → 500 · 842ms

Parameters

Captures: Method arguments and request parameters at execution time.
Why it matters: Inspect the inputs that triggered the failure instead of adding LogInformation everywhere.

Example orderId=1042 · customerId=7a3f…

SQL

Captures: EF Core and ADO.NET queries with parameters and duration.
Why it matters: Find slow or failing database work tied to the parent request.

Example SELECT … FROM Orders WHERE Id = @id · 18ms

HTTP

Captures: Outbound HTTP requests and responses with URL, status, and timing.
Why it matters: Debug downstream API failures from production evidence.

Example GET payments.example.com → 503 · 61ms

Exceptions

Captures: Exception type, message, and stack trace when instrumented methods fail.
Why it matters: See the failure moment with surrounding context—not a lone error line in a log file.

Example PaymentDeclinedException: card declined

Trace Context

Captures: Trace IDs, nested call hierarchy, and duration on a correlated timeline.
Why it matters: Follow one production request end-to-end without manually stitching log lines.

Example trace:fa7dedf4-ec83-4b6e-a3f3-…

Automatic Instrumentation

Captures: Method entry, exit, and duration from compile-time IL weaving on [LogMethod] and configured aspects.
Why it matters: Get deep execution context without rewriting business logic for logging.

Example [LogMethod] on OrdersController.Create

How it works

From .NET application to actionable context.

Install NuGet packages, let automatic instrumentation capture production execution, and investigate from ArgusLogs.UI.

.NET App

Instrumentation

Execution

Capture

Platform

Search / Analyze / Debug

Build

Add ArgusLogs NuGet packages and apply [LogMethod] or configured aspects to the methods you want instrumented.

Capture

At runtime, woven code records SQL, HTTP, parameters, exceptions, and trace context around each instrumented request.

Analyze

Search by trace ID, user, or route in ArgusLogs.UI and open the correlated timeline for the failing request.

Debug

Fix from production evidence—without reproducing the incident or shipping another logging deploy.

Explore How Argus Works

Production debugging

Don't reproduce the problem. Investigate what already happened.

Many production failures can't be replayed—a specific user, load pattern, or integration state never shows up on your machine. ArgusLogs captures SQL, HTTP, parameters, and exceptions from the live request so you investigate from what already ran.

Explore Production Debugging

Microservices

Follow the request beyond a single service.

One checkout can cross an API gateway, order and inventory services, database queries, and a payment API. ArgusLogs records SQL, HTTP, and exceptions on each instrumented .NET service with shared trace IDs so you follow the path in ArgusLogs.UI.

API Gateway

Orders

Inventory

Payment

Correlates traces across instrumented .NET services and captured outbound HTTP—where trace headers and NetworkTracker are configured.

Explore .NET Distributed Tracing

Built for .NET

Deep visibility without leaving the .NET ecosystem.

ArgusLogs ships as multi-target NuGet packages for .NET 5 through .NET 10—with ASP.NET Core, EF Core, ADO.NET, and HttpClient integrations where configured.

.NET 5
.NET 6
.NET 7
.NET 8
.NET 9
.NET 10
ASP.NET Core
EF Core
ADO.NET
HttpClient

Explore Argus for .NET View supported versions

For developers

Spend less time adding logs. More time building software.

Write your application. Let Argus capture the context.

Traditional Logging

public async Task<Order> ProcessOrder(Order req)
{
    var sw = Stopwatch.StartNew();
    _logger.LogInfo($"Start ProcessOrder for {req.Id}");
    try
    {
        var result = await _db.Orders.AddAsync(req);
        _logger.LogInfo($"Successfully saved Order {req.Id}");
        sw.Stop();
        _logger.LogMetric("ProcessOrder_Duration", sw.ElapsedMs);
        return result;
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, $"Failed to process {req.Id}");
        throw;
    }
}

The ArgusLogs Way

[LogMethod]
public async Task<Order> ProcessOrder([Sensitive] Order req)
{
    // That's it.
    // ArgusLogs handles the rest automatically.
    return await _db.Orders.AddAsync(req);
}

Get Started in Minutes

Use cases

Built for the moments when production gets complicated.

Production Debugging

Investigate live failures with SQL, HTTP, and exceptions captured automatically—without reproducing the bug.

Explore

API Troubleshooting

Trace failed API requests with inbound routes, outbound calls, and correlated context.

Explore

Database Investigation

Find slow or failing queries with parameters and duration tied to the parent request.

Explore

Microservices

Follow shared trace IDs across instrumented .NET services and captured HTTP hops.

Explore

Incident Investigation

Reconstruct what happened during an outage from production evidence in one timeline.

Explore

Customer Issues

Filter by user ID or trace ID in ArgusLogs.UI to debug one customer's failing journey.

Explore

Quick start

Go from installation to your first captured request quickly.

Generate a license key

Create a Development or Production key without signing in. Paste ArgusLogsKey into appsettings.json.

Install

Add ArgusLogs and ArgusLogs.DataAnnotation NuGet packages to your .NET project.

Configure

Apply [LogMethod] or aspects and wire ASP.NET Core middleware where needed.

First request

Deploy and exercise your app—woven instrumentation captures context on the first live request.

First trace

Open ArgusLogs.UI, search by trace ID or route, and inspect the correlated timeline.

Install from NuGet

Latest published packages for .NET projects. · 1.0.11-alpha.2608292142

dotnet CLI

dotnet add package ArgusLogs --version 1.0.11-alpha.2608292142
dotnet add package ArgusLogs.DataAnnotation --version 1.0.11-alpha.2608292142

Read the Quick Start Developer tutorial Start Free

Performance

Observability shouldn't become your next performance problem.

ArgusLogs uses compile-time instrumentation—not runtime reflection or hand-written logging in every method. Same machine, same payload, BenchmarkDotNet versus ILogger + Serilog.

360 nsOne log line
3.2× fastervs Serilog
668 BAllocated
7.7× faster[LogMethod]

Means from the published run. [LogMethod] vs the matching hand-written ILogger ENTER/EXIT. Full tables and methodology on the benchmarks page.

Explore performance benchmarks

Security

Your production data deserves production-grade protection.

Control sensitive parameters, who can open ArgusLogs.UI, and how long telemetry is retained—without sending production data to a mandatory SaaS pipeline.

Encrypt parameters tagged with [Sensitive] in captured context.
Protect ArgusLogs.UI with login and authorization filters in production.
Configure TieredStorage retention and archive policies for your telemetry.

Explore security best practices

Compare

Choose the right tool for the problem you're solving.

ArgusLogs focuses on deep .NET production debugging—not replacing every logger or APM suite. The table below shows how automatic instrumentation compares to traditional logging for the investigation tasks teams care about most.

Feature	ArgusLogs	Traditional
Business Code Pollution	Clean business code (automatic instrumentation)	High (Manual _logger.Log() everywhere)
Investigation depth	Parameters, return values, duration, SQL, and HTTP in one correlated view	Shallow text messages
Sensitive data in production	Automatic encryption for tagged parameters via [Sensitive]	Requires DIY masking or complex plugins
SQL & HTTP context	See queries and outbound calls tied to the failing request	Needs complex custom enrichers
One view per request	One structured entry connects start, end, errors, and child spans	Scattered Start/Stop/Error entries
Follow one user or trace	Group by UserId or TraceId without a separate analytics pipeline	Requires ELK/Splunk to trace a user

Different tools solve different problems. Serilog, OpenTelemetry, Elastic, Datadog, and Dynatrace each excel in their own domains—we outline where ArgusLogs fits alongside them on our dedicated comparison pages.

Compare Argus

Pricing

Spend less time debugging, not more on observability.

ArgusLogs is free to use—you generate a license key after signup. No APM-style ingestion tax when you need deeper visibility during an incident.

Free

Start in Development with a free license key.

Free

Free Plus

For Staging—with optional tracker features where your plan allows.

Free

Free Pro

For Production with the full ArgusLogs feature set.

All plans are free today. Plan duration and feature limits are shown during license setup.

View Pricing Start Free

Under the hood

Built for developers who want to know how it works.

Explore how compile-time weaving, automatic instrumentation, and ArgusLogs packages fit together—from architecture to data capture in production.

NuGet

Configure once and correlate execution context across threads and requests during production incidents.

NuGet

ArgusLogs.DataAnnotation

Automatically instruments .NET assemblies at build time—telemetry is woven in without runtime reflection.

NuGet

ArgusLogs.UI

Investigate traces at /argus-logs with search and drill-down—no separate log viewer required.

ArgusLogs

SubscriptionManager

RSA-backed license checks and offline entitlement validation for enterprise deployments.

Who it's for

Built for .NET teams shipping to production

ArgusLogs is not generic observability for every stack—it is purpose-built for .NET engineers, the leads who run incidents, and the leaders who own reliability.

Primary · .NET developers

Investigate incidents from real execution context

Filter traces in ArgusLogs.UI, inspect SQL and HTTP child spans, and follow exceptions with parameters captured automatically—without littering controllers and services with LogInformation calls.

Secondary · Tech leads & engineering managers

Shorten MTTR when production breaks

Give on-call engineers correlated request timelines instead of log archaeology. Resolve incidents faster when every method, query, and outbound call shares a trace ID.

Leadership · CTOs & engineering directors

Production reliability without agent sprawl

Keep telemetry on your infrastructure with TieredStorage and the embedded UI. Reduce dependence on heavyweight SaaS APM for .NET-only estates while improving incident visibility.

Embedded diagnostics

ArgusLogs.UI — live dashboard in your app

Mount the embedded log viewer at /argus-logs to browse histograms, KQL search, and trace detail without shipping logs to a separate SaaS dashboard.

Live dashboard walkthrough

ArgusLogs.UI embedded diagnostics dashboard with log table, histogram, and KQL search bar — ArgusLogs.UI dashboard — filter, search, and inspect structured telemetry in-process.

FAQ

Questions about production debugging with ArgusLogs

What is ArgusLogs?

ArgusLogs is a production debugging and observability platform for .NET applications. Compile-time IL weaving captures execution context—requests, SQL, HTTP, exceptions, and traces—so teams can investigate production incidents without reproducing bugs or sprinkling manual log statements through business code.

Who is ArgusLogs for?

ArgusLogs is built for .NET developers debugging production systems, tech leads and engineering managers who need faster incident resolution, and CTOs or engineering directors who want production reliability without heavyweight SaaS agents on every .NET host.

What does ArgusLogs capture?

Where supported by your configuration and integrations, ArgusLogs records structured telemetry including:

API and HTTP requests and responses
Request parameters and method arguments
SQL queries (EF Core and ADO.NET)
Exceptions and stack traces
Trace IDs and execution duration
Method entry, exit, and contextual metadata

How is ArgusLogs different?

Traditional logging depends on developers predicting what to log before an incident. ArgusLogs uses compile-time instrumentation to capture execution context automatically—parameters, SQL, HTTP, and exceptions in one correlated view—without sprinkling LogInformation calls through business code.

Frequently asked questions

What problem does ArgusLogs solve?

Production .NET failures often lack the SQL, HTTP, and parameter context needed to understand root cause. Teams waste cycles reproducing bugs or redeploying with temporary logging. ArgusLogs captures that forensic context automatically so you investigate from evidence captured when the failure happened.

How does ArgusLogs work?

Install ArgusLogs NuGet packages, enable argus-weaver at build time, and call UseArgus() in Program.cs. Compile-time IL weaving injects aspects around configured methods; at runtime structured telemetry flows to sinks, TieredStorage, or ArgusLogs.UI at /argus-logs. See /how-it-works for the full flow.

Does ArgusLogs replace manual logging?

ArgusLogs reduces the need for repetitive LogInformation calls for parameters, SQL, and HTTP context. You may still use ILogger or Serilog for business events you choose to emit. ArgusLogs focuses on automatic execution forensics; manual logs and ArgusLogs structured output can coexist.

How does ArgusLogs compare to Datadog?

Datadog is a cloud APM platform priced around ingest and host licensing. ArgusLogs is a .NET-native production debugging platform with compile-time instrumentation and optional embedded UI—you control where telemetry lives without mandatory SaaS ingest. See /compare/argus-vs-datadog for a feature-by-feature comparison.

What is automatic instrumentation in ArgusLogs?

Automatic instrumentation means ArgusLogs weaves logging and tracing aspects into your .NET assemblies at compile time via argus-weaver and [LogMethod]. You configure which methods are instrumented; the runtime captures entry, exit, parameters, SQL, HTTP, and exceptions without hand-written logging in every code path. See /learn/what-is-automatic-instrumentation.

Does ArgusLogs require code changes?

You add NuGet packages and apply [LogMethod] or similar annotations to methods you want instrumented. You do not need repetitive LogInformation calls for parameters, SQL, or HTTP context.

Which .NET versions are supported?

ArgusLogs NuGet packages multi-target .NET 5, .NET 6, .NET 7, .NET 8, .NET 9, .NET 10. See /docs/dotnet-versions for package alignment details.

Does ArgusLogs support ASP.NET Core?

Yes. ASP.NET Core HTTP request and response capture is supported where the NetworkTracker integration is configured. See /docs/aspnet-core and /aspnet-core-logging.

How does ArgusLogs compare to Serilog?

Serilog is a logging library—you choose what to write and when. ArgusLogs is a production debugging platform that captures method, SQL, HTTP, and exception context automatically via compile-time weaving. See /compare/argus-vs-serilog for a fair comparison.

How does ArgusLogs relate to OpenTelemetry?

OpenTelemetry standardizes traces and metrics export. ArgusLogs focuses on deep .NET instrumentation at compile time and can complement OTel in hybrid setups. See /compare/argus-vs-opentelemetry and /learn/what-is-automatic-instrumentation.

Is ArgusLogs suitable for production?

Yes. ArgusLogs is designed for production debugging—instrumentation is woven at build time, sensitive parameters can be encrypted with [Sensitive], ArgusLogs.UI supports login and authorization filters, and TieredStorage retention policies help you control how long telemetry is kept.

Where is the documentation?

Start at /docs/getting-started, follow the developer tutorial at /tutorial, and browse topical guides such as /dotnet-observability.

What is ArgusLogs.UI?

ArgusLogs.UI is an embedded diagnostics dashboard mounted at /argus-logs in your ASP.NET Core app. It provides histograms, KQL search, and method trace detail without shipping logs to a separate SaaS.

Stop guessing what happened in production.

Built for .NET. Designed for developers. Ready for production.

Start Free Read the Documentation

Stay in the loop

Get product updates by email

Join ArgusLogs followers for release notes, tutorial drops, and launch news. No spam — unsubscribe anytime.