kwaak 0.1.4

Run a team of autonomous agents on your code, right from your terminal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use crate::repository::Repository;
use anyhow::Result;
use tracing::level_filters::LevelFilter;
use tracing_opentelemetry::OpenTelemetryLayer;
use tracing_subscriber::prelude::*;
use tracing_subscriber::{fmt, EnvFilter};

// For now just log to stdout and file
pub fn init(repository: &Repository) -> Result<()> {
    let log_dir = repository.config().log_dir();

    let file_appender = tracing_appender::rolling::daily(
        log_dir,
        format!("{}.log", repository.config().project_name),
    );

    let fmt_layer = fmt::layer().with_writer(file_appender);

    // Logs the file layer will capture
    let mut env_filter_layer = EnvFilter::builder()
        .with_default_directive(LevelFilter::INFO.into())
        .from_env_lossy()
        .add_directive("h2=error".parse().unwrap())
        .add_directive("tower=error".parse().unwrap())
        .add_directive("tui_markdown=error".parse().unwrap());

    if cfg!(feature = "otel") {
        env_filter_layer = env_filter_layer
            .add_directive("swiftide=trace".parse().unwrap())
            .add_directive("swiftide_indexing=trace".parse().unwrap())
            .add_directive("swiftide_integrations=trace".parse().unwrap())
            .add_directive("swiftide_query=trace".parse().unwrap())
            .add_directive("swiftide_agents=trace".parse().unwrap())
            .add_directive("swiftide_core=trace".parse().unwrap())
            .add_directive("kwaak=trace".parse().unwrap());
    }

    // The log level tui logger will capture
    let default_level = if cfg!(debug_assertions) {
        log::LevelFilter::Info
    } else {
        log::LevelFilter::Warn
    };
    let tui_layer = tui_logger::tracing_subscriber_layer();
    tui_logger::init_logger(default_level)?;

    let mut layers = vec![
        // env_filter_layer.boxed(),
        tui_layer.boxed(),
        fmt_layer.boxed(),
    ];

    if cfg!(feature = "otel") {
        dbg!("OpenTelemetry tracing enabled");
        let provider = otel_provider();
        let tracer = provider.tracer("kwaak");
        opentelemetry::global::set_tracer_provider(provider);

        // Create a tracing layer with the configured tracer
        let layer = OpenTelemetryLayer::new(tracer);

        layers.push(layer.boxed());
    }

    let registry = tracing_subscriber::registry()
        .with(env_filter_layer)
        .with(layers);
    registry.try_init()?;

    Ok(())
}

#[cfg(feature = "otel")]
use opentelemetry::trace::TracerProvider as _;
#[cfg(feature = "otel")]
use opentelemetry_sdk::trace::TracerProvider;

#[cfg(feature = "otel")]
fn otel_provider() -> TracerProvider {
    use opentelemetry_sdk::runtime;
    use opentelemetry_sdk::trace::TracerProvider;

    let exporter = opentelemetry_otlp::SpanExporter::builder()
        .with_tonic()
        .build()
        .expect("failed to create otlp exporter");

    #[allow(deprecated, reason = "fix it when it breaks")]
    TracerProvider::builder()
        .with_batch_exporter(exporter, runtime::Tokio)
        .with_config(opentelemetry_sdk::trace::Config::default().with_resource(
            opentelemetry_sdk::Resource::new(vec![opentelemetry::KeyValue::new(
                "service.name",
                "kwaak",
            )]),
        ))
        .build()
}