Java SDK

Basic Usage

import dev.autonoma.sdk.Autonoma;
import dev.autonoma.sdk.AnalysisResult;
import dev.autonoma.sdk.Prediction;

public class Example {
    public static void main(String[] args) {
        // Initialize client
        Autonoma autonoma = Autonoma.builder()
            .apiKey(System.getenv("AUTONOMA_API_KEY"))
            .environment("production")
            .build();
        
        // Start monitoring
        autonoma.start();
        
        // Analyze code
        String content = Files.readString(Paths.get("App.java"));
        AnalysisResult result = autonoma.analyze(
            AnalyzeOptions.builder()
                .file("App.java")
                .content(content)
                .build()
        );
        
        // Get predictions
        List<Prediction> predictions = autonoma.getPredictions();
        
        // Apply auto-fix
        for (Prediction pred : predictions) {
            if (pred.isAutoFixAvailable()) {
                FixResult fixResult = autonoma.applyFix(pred.getId());
                System.out.println("Fix applied: " + fixResult.isSuccess());
            }
        }
        
        // Clean up
        autonoma.close();
    }
}

Spring Boot Integration

// application.yml
autonoma:
  api-key: ${AUTONOMA_API_KEY}
  environment: production
  auto-fix:
    enabled: true
    confidence-threshold: 0.95
  monitoring:
    enabled: true
    sample-rate: 1.0

// Main Application
@SpringBootApplication
@EnableAutonoma
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// Service
@Service
public class UserService {
    
    @Autowired
    private Autonoma autonoma;
    
    @Monitored
    public User createUser(UserDto dto) {
        // Method is automatically monitored
        return userRepository.save(convertToEntity(dto));
    }
    
    @AutoFix
    public void processPayment(Payment payment) {
        // Autonoma will automatically fix issues in this method
        // when confidence is high enough
    }
}

// Controller with automatic error handling
@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        // Errors are automatically captured by Autonoma
        return ResponseEntity.ok(userService.findById(id));
    }
}

Kotlin Support

import dev.autonoma.sdk.autonoma
import kotlinx.coroutines.*

fun main() = runBlocking {
    // DSL-style initialization
    val autonoma = autonoma {
        apiKey = System.getenv("AUTONOMA_API_KEY")
        environment = "production"
        autoFix {
            enabled = true
            confidenceThreshold = 0.95
        }
    }
    
    // Coroutine support
    val result = autonoma.analyzeAsync {
        file = "App.kt"
        content = File("App.kt").readText()
    }
    
    // Extension functions
    val predictions = autonoma.predictions()
        .filter { it.severity == Severity.CRITICAL }
        .map { it.applyFixIfAvailable() }
    
    // Flow support
    autonoma.predictionFlow()
        .filter { it.autoFixAvailable }
        .collect { prediction ->
            println("New prediction: ${prediction.message}")
        }
}

// Data class support
data class CustomMetric(
    val name: String,
    val value: Double,
    val tags: Map<String, String> = emptyMap()
)

// Extension function
suspend fun Prediction.applyFixIfAvailable(): FixResult? {
    return if (autoFixAvailable) {
        autonoma.applyFix(id)
    } else null
}

Reactive Programming

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@Service
public class ReactiveService {
    
    private final ReactiveAutonoma autonoma;
    
    // Analyze files reactively
    public Flux<AnalysisResult> analyzeProject(String directory) {
        return Flux.fromIterable(Files.list(Paths.get(directory)))
            .filter(path -> path.toString().endsWith(".java"))
            .flatMap(path -> 
                Mono.fromCallable(() -> Files.readString(path))
                    .flatMap(content -> autonoma.analyze(
                        AnalyzeOptions.builder()
                            .file(path.toString())
                            .content(content)
                            .build()
                    ))
            );
    }
    
    // Stream predictions
    public Flux<Prediction> streamPredictions() {
        return autonoma.getPredictionsFlux()
            .filter(pred -> pred.getSeverity() == Severity.HIGH)
            .doOnNext(pred -> log.info("High severity: {}", pred.getMessage()));
    }
    
    // WebFlux integration
    @GetMapping(value = "/predictions/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<ServerSentEvent<Prediction>> streamToClient() {
        return autonoma.getPredictionsFlux()
            .map(prediction -> ServerSentEvent.<Prediction>builder()
                .data(prediction)
                .build());
    }
}

analyze(AnalyzeOptions options)

Analyze code for potential issues, performance problems, and security vulnerabilities.

// Single file analysis
AnalysisResult result = autonoma.analyze(
    AnalyzeOptions.builder()
        .file("UserService.java")
        .content(fileContent)
        .context(Map.of(
            "framework", "spring",
            "javaVersion", "11"
        ))
        .build()
);

// Batch analysis
List<AnalysisResult> results = autonoma.analyzeBatch(
    Arrays.asList(
        AnalyzeOptions.builder().file("Service.java").content(content1).build(),
        AnalyzeOptions.builder().file("Controller.java").content(content2).build()
    )
);

// With specific rules
AnalysisResult result = autonoma.analyze(
    AnalyzeOptions.builder()
        .file("PaymentService.java")
        .content(content)
        .rules(Arrays.asList("security", "performance"))
        .severityThreshold(Severity.MEDIUM)
        .build()
);

// Async analysis
CompletableFuture<AnalysisResult> future = autonoma.analyzeAsync(options);
future.thenAccept(result -> {
    System.out.printf("Found %d issues in %s%n", 
        result.getPredictions().size(), 
        result.getFile());
});

// Stream processing
Files.walk(Paths.get("src"))
    .filter(path -> path.toString().endsWith(".java"))
    .parallel()
    .map(path -> autonoma.analyze(createOptions(path)))
    .forEach(this::processResult);

getPredictions(PredictionFilters filters)

Retrieve predictions for your codebase with optional filtering.

// Get all predictions
List<Prediction> predictions = autonoma.getPredictions();

// Filter by severity and type
PredictionFilters filters = PredictionFilters.builder()
    .severities(Arrays.asList(Severity.CRITICAL, Severity.HIGH))
    .type("security")
    .status(PredictionStatus.OPEN)
    .build();
List<Prediction> filtered = autonoma.getPredictions(filters);

// With pagination
Page<Prediction> page = autonoma.getPredictionsPaged(
    filters,
    PageRequest.of(0, 50, Sort.by("severity").descending())
);

// Stream processing
autonoma.getPredictions().stream()
    .filter(pred -> pred.getConfidence() > 0.9)
    .filter(Prediction::isAutoFixAvailable)
    .forEach(pred -> autonoma.applyFix(pred.getId()));

// Group by severity
Map<Severity, List<Prediction>> bySeverity = 
    autonoma.getPredictions().stream()
        .collect(Collectors.groupingBy(Prediction::getSeverity));

applyFix(String predictionId, FixOptions options)

Apply an auto-fix for a specific prediction with validation and rollback support.

// Apply fix with default settings
FixResult result = autonoma.applyFix("pred_123abc");

// Apply with options
FixOptions options = FixOptions.builder()
    .dryRun(true)           // Preview changes
    .createBackup(true)     // Backup before applying
    .runTests(true)         // Run tests after fix
    .testCommand("mvn test")
    .autoCommit(false)
    .commitMessage("fix: resolve SQL injection vulnerability")
    .build();
FixResult result = autonoma.applyFix("pred_123abc", options);

// Handle result
if (result.isSuccess()) {
    System.out.println("Fix applied successfully!");
    System.out.printf("Files changed: %d%n", result.getFilesChanged().size());
    System.out.printf("Lines modified: %d%n", result.getLinesModified());
    
    // Review changes
    result.getChanges().forEach(change -> {
        System.out.printf("  %s: %s%n", change.getFile(), change.getDescription());
    });
} else {
    System.err.printf("Fix failed: %s%n", result.getError());
    
    // Rollback if available
    if (result.getRollbackId() != null) {
        autonoma.rollback(result.getRollbackId());
    }
}

// Batch fixes with transaction support
TransactionTemplate txTemplate = new TransactionTemplate(txManager);
txTemplate.execute(status -> {
    try {
        List<String> predictionIds = getHighConfidencePredictions();
        BatchFixResult batchResult = autonoma.applyFixes(
            predictionIds,
            BatchFixOptions.builder()
                .stopOnError(true)
                .parallel(false)
                .build()
        );
        
        if (!batchResult.isAllSuccessful()) {
            status.setRollbackOnly();
        }
        return batchResult;
    } catch (Exception e) {
        status.setRollbackOnly();
        throw e;
    }
});

Monitoring Methods

Monitor application performance and errors in real-time.

// Start monitoring
autonoma.start();

// Capture exceptions
try {
    riskyOperation();
} catch (Exception e) {
    autonoma.captureException(e, 
        ErrorContext.builder()
            .user(userId)
            .tags(Map.of(
                "component", "payment",
                "version", "2.1.0"
            ))
            .extra(Map.of(
                "orderId", orderId,
                "amount", amount
            ))
            .build()
    );
}

// Performance timing
try (Timer timer = autonoma.startTimer("database.query")) {
    return jdbcTemplate.query(sql, rowMapper);
} // Timer automatically records duration

// Custom metrics
autonoma.metric("api.requests", 1, 
    MetricTags.of("endpoint", "/api/users", "method", "GET"));

autonoma.gauge("queue.size", queue.size());
autonoma.histogram("response.size", response.length());

// Annotation-based monitoring
@Timed("user.service.create")
@Counted("user.created")
public User createUser(UserDto dto) {
    return userRepository.save(convertToEntity(dto));
}

// Method interceptor for automatic monitoring
@Bean
public MethodInterceptor autonomaInterceptor(Autonoma autonoma) {
    return invocation -> {
        String methodName = invocation.getMethod().getName();
        try (Timer timer = autonoma.startTimer("method." + methodName)) {
            return invocation.proceed();
        } catch (Exception e) {
            autonoma.captureException(e);
            throw e;
        }
    };
}

Distributed Tracing

// Spring Cloud Sleuth integration
@Configuration
@EnableAutoConfiguration
public class AutonomaTracingConfig {
    
    @Bean
    public TracingCustomizer autonomaTracingCustomizer(Autonoma autonoma) {
        return builder -> builder
            .addSpanHandler(new AutonomaSpanHandler(autonoma))
            .addSpanExporter(new AutonomaSpanExporter(autonoma));
    }
}

// Service mesh support
@Component
public class AutonomaInterceptor implements ClientHttpRequestInterceptor {
    
    @Override
    public ClientHttpResponse intercept(HttpRequest request, 
                                      byte[] body, 
                                      ClientHttpRequestExecution execution) {
        // Add trace headers
        request.getHeaders().add("X-Autonoma-Trace-Id", 
            autonoma.getCurrentTraceId());
        
        try (Span span = autonoma.startSpan("http.client")) {
            span.tag("http.method", request.getMethod().toString());
            span.tag("http.url", request.getURI().toString());
            
            ClientHttpResponse response = execution.execute(request, body);
            span.tag("http.status", response.getStatusCode().value());
            
            return response;
        }
    }
}

// Kafka integration
@Component
public class AutonomaKafkaListener {
    
    @KafkaListener(topics = "orders")
    @AutonomaTrace
    public void processOrder(Order order, 
                           @Header("autonoma-trace-id") String traceId) {
        autonoma.continueTrace(traceId);
        // Process order with tracing
    }
}

// Circuit breaker integration
@Component
public class PaymentService {
    
    @CircuitBreaker(name = "payment", fallbackMethod = "fallbackPayment")
    @AutonomaMonitor
    public PaymentResult processPayment(Payment payment) {
        return externalPaymentService.process(payment);
    }
    
    public PaymentResult fallbackPayment(Payment payment, Exception e) {
        autonoma.captureException(e, ErrorContext.builder()
            .tags(Map.of("fallback", "true"))
            .build());
        return PaymentResult.failed("Service unavailable");
    }
}