Add Auditaur to a Tauri App

Use this guide when you already have a Tauri v2 app and want Auditaur telemetry available to humans and coding agents.

Current published packages:

Package	Version
tauri-plugin-auditaur	0.4.0
@auditaur/api	0.5.1

1. Install the CLI

cargo install auditaur-cli
auditaur doctor

2. Add the Rust plugin

In src-tauri\Cargo.toml:

[dependencies]
tauri-plugin-auditaur = "0.4.0"
tracing = "0.1"
tracing-subscriber = "0.3"

Register the plugin in src-tauri\src\main.rs:

use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

fn main() {
    tracing_subscriber::registry()
        .with(tauri_plugin_auditaur::tracing_layer())
        .init();

    tauri::Builder::default()
        .plugin(
            tauri_plugin_auditaur::Builder::new()
                .service_name("my-tauri-app")
                .session_name("dev")
                .redact_defaults(true)
                .max_session_bytes(256 * 1024 * 1024)
                .build(),
        )
        .run(tauri::generate_context!())
        .expect("failed to run app");
}

Auditaur is development-first. Release builds are blocked by default; only set allow_release_builds(true) after reviewing the data your app emits and the privacy expectations for your users.

3. Allow the frontend plugin command

In src-tauri\capabilities\default.json, include auditaur:default:

{
  "$schema": "../gen/schemas/desktop-schema.json",
  "identifier": "default",
  "windows": ["main"],
  "permissions": ["core:default", "auditaur:default"]
}

4. Add the frontend package

npm install @auditaur/api@0.5.1

Initialize Auditaur once near app startup:

import { initAuditaur } from '@auditaur/api';

export const auditaur = await initAuditaur({
  serviceName: 'my-tauri-app',
  instrumentConsole: true,
  instrumentErrors: true,
  instrumentTauriInvoke: true,
  propagateTauriInvokeTraceContext: true,
  instrumentTauriEvents: true,
  captureFullPayloads: false,
});

5. Adopt invoke() gradually

Auditaur does not globally monkey-patch @tauri-apps/api/core. Prefer a local wrapper and migrate imports over time.

Create src\services\tauri.ts:

import { initAuditaur } from '@auditaur/api';

const auditaur = await initAuditaur({
  serviceName: 'my-tauri-app',
});

export const invoke = auditaur.invoke;
export const emit = auditaur.emit;
export const emitTo = auditaur.emitTo;
export const listen = auditaur.listen;
export const flushAuditaur = () => auditaur.flush();

Then replace direct imports:

import { invoke } from '@tauri-apps/api/core';
import { invoke } from './services/tauri';

You can migrate command-by-command. Direct @tauri-apps/api/core calls still work; they just will not get Auditaur invoke spans or trace propagation until routed through the wrapper.

6. Opt backend commands into IPC trace continuation

For commands you want parented under frontend invoke traces, prefer auditaur_command. It wraps #[tauri::command], injects the trace carriers Auditaur needs, and keeps backend command spans parented to frontend invoke spans:

#[tauri_plugin_auditaur::auditaur_command]
fn load_user(id: String) -> Result<String, String> {
    tracing::info!(user.id = %id, "loading user");
    Ok(id)
}

If you need to keep an explicit #[tauri::command], use the lower-level compatibility helper:

use tauri_plugin_auditaur::IpcTraceContext;

#[tauri::command]
#[tauri_plugin_auditaur::instrument_ipc(err)]
fn load_user_legacy(
    id: String,
    auditaur_trace_context: Option<IpcTraceContext>,
) -> Result<String, String> {
    tracing::info!(user.id = %id, "loading user");
    Ok(id)
}

For instrument_ipc, the optional parameter must be named auditaur_trace_context.

Because auditaur_command injects a borrowed tauri::ipc::Request<'_> argument, it can only wrap an infallible async getter (e.g. async fn get_status() -> Status) if you first give it a Result return — Tauri requires every async command with a reference input to return Result. To keep the bare return on an async getter, use the #[tauri::command] + #[instrument_ipc(...)] form above with an auditaur_trace_context: Option<IpcTraceContext> parameter; the trace still continues via the auditaurTraceContext payload arg. Applying auditaur_command to such a getter now fails with a clear compile error explaining these two options.

7. Verify with doctor and read commands

Run these while the app is open in tauri dev:

auditaur doctor tauri --path src-tauri --json
auditaur apps --json
auditaur health --json
auditaur logs --json
auditaur traces --failed --json
auditaur exceptions --json

Healthy discovery looks like:

[
  {
    "serviceName": "my-tauri-app",
    "status": "active",
    "databaseReadable": true,
    "schemaValid": true,
    "databasePath": "..."
  }
]

If multiple active sessions exist, copy databasePath from auditaur apps --json and pass it explicitly. If you started the app with auditaur observe or auditaur start, prefer the pinned session file instead:

auditaur logs --session-file .auditaur\session.json --json
auditaur exceptions --session-file .auditaur\session.json --json