8d9b62daf3
This commit implements Phase 2 of the CHORUS Task Execution Engine development plan, providing a comprehensive execution environment abstraction layer with Docker container sandboxing support. ## New Features ### Core Sandbox Interface - Comprehensive ExecutionSandbox interface with isolated task execution - Support for command execution, file I/O, environment management - Resource usage monitoring and sandbox lifecycle management - Standardized error handling with SandboxError types and categories ### Docker Container Sandbox Implementation - Full Docker API integration with secure container creation - Transparent repository mounting with configurable read/write access - Advanced security policies with capability dropping and privilege controls - Comprehensive resource limits (CPU, memory, disk, processes, file handles) - Support for tmpfs mounts, masked paths, and read-only bind mounts - Container lifecycle management with proper cleanup and health monitoring ### Security & Resource Management - Configurable security policies with SELinux, AppArmor, and Seccomp support - Fine-grained capability management with secure defaults - Network isolation options with configurable DNS and proxy settings - Resource monitoring with real-time CPU, memory, and network usage tracking - Comprehensive ulimits configuration for process and file handle limits ### Repository Integration - Seamless repository mounting from local paths to container workspaces - Git configuration support with user credentials and global settings - File inclusion/exclusion patterns for selective repository access - Configurable permissions and ownership for mounted repositories ### Testing Infrastructure - Comprehensive test suite with 60+ test cases covering all functionality - Docker integration tests with Alpine Linux containers (skipped in short mode) - Mock sandbox implementation for unit testing without Docker dependencies - Security policy validation tests with read-only filesystem enforcement - Resource usage monitoring and cleanup verification tests ## Technical Details ### Dependencies Added - github.com/docker/docker v28.4.0+incompatible - Docker API client - github.com/docker/go-connections v0.6.0 - Docker connection utilities - github.com/docker/go-units v0.5.0 - Docker units and formatting - Associated Docker API dependencies for complete container management ### Architecture - Interface-driven design enabling multiple sandbox implementations - Comprehensive configuration structures for all sandbox aspects - Resource usage tracking with detailed metrics collection - Error handling with retryable error classification - Proper cleanup and resource management throughout sandbox lifecycle ### Compatibility - Maintains backward compatibility with existing CHORUS architecture - Designed for future integration with Phase 3 Core Task Execution Engine - Extensible design supporting additional sandbox implementations (VM, process) This Phase 2 implementation provides the foundation for secure, isolated task execution that will be integrated with the AI model providers from Phase 1 in the upcoming Phase 3 development. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
60 lines
3.0 KiB
Go
60 lines
3.0 KiB
Go
// Copyright The OpenTelemetry Authors
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
package trace // import "go.opentelemetry.io/otel/trace"
|
|
|
|
import "go.opentelemetry.io/otel/trace/embedded"
|
|
|
|
// TracerProvider provides Tracers that are used by instrumentation code to
|
|
// trace computational workflows.
|
|
//
|
|
// A TracerProvider is the collection destination of all Spans from Tracers it
|
|
// provides, it represents a unique telemetry collection pipeline. How that
|
|
// pipeline is defined, meaning how those Spans are collected, processed, and
|
|
// where they are exported, depends on its implementation. Instrumentation
|
|
// authors do not need to define this implementation, rather just use the
|
|
// provided Tracers to instrument code.
|
|
//
|
|
// Commonly, instrumentation code will accept a TracerProvider implementation
|
|
// at runtime from its users or it can simply use the globally registered one
|
|
// (see https://pkg.go.dev/go.opentelemetry.io/otel#GetTracerProvider).
|
|
//
|
|
// Warning: Methods may be added to this interface in minor releases. See
|
|
// package documentation on API implementation for information on how to set
|
|
// default behavior for unimplemented methods.
|
|
type TracerProvider interface {
|
|
// Users of the interface can ignore this. This embedded type is only used
|
|
// by implementations of this interface. See the "API Implementations"
|
|
// section of the package documentation for more information.
|
|
embedded.TracerProvider
|
|
|
|
// Tracer returns a unique Tracer scoped to be used by instrumentation code
|
|
// to trace computational workflows. The scope and identity of that
|
|
// instrumentation code is uniquely defined by the name and options passed.
|
|
//
|
|
// The passed name needs to uniquely identify instrumentation code.
|
|
// Therefore, it is recommended that name is the Go package name of the
|
|
// library providing instrumentation (note: not the code being
|
|
// instrumented). Instrumentation libraries can have multiple versions,
|
|
// therefore, the WithInstrumentationVersion option should be used to
|
|
// distinguish these different codebases. Additionally, instrumentation
|
|
// libraries may sometimes use traces to communicate different domains of
|
|
// workflow data (i.e. using spans to communicate workflow events only). If
|
|
// this is the case, the WithScopeAttributes option should be used to
|
|
// uniquely identify Tracers that handle the different domains of workflow
|
|
// data.
|
|
//
|
|
// If the same name and options are passed multiple times, the same Tracer
|
|
// will be returned (it is up to the implementation if this will be the
|
|
// same underlying instance of that Tracer or not). It is not necessary to
|
|
// call this multiple times with the same name and options to get an
|
|
// up-to-date Tracer. All implementations will ensure any TracerProvider
|
|
// configuration changes are propagated to all provided Tracers.
|
|
//
|
|
// If name is empty, then an implementation defined default name will be
|
|
// used instead.
|
|
//
|
|
// This method is safe to call concurrently.
|
|
Tracer(name string, options ...TracerOption) Tracer
|
|
}
|