This repository implements a Serilog sink for writing log events to Microsoft SQL Server and Azure SQL databases. It provides both regular (batched) and audit (synchronous) sink variants, supporting automatic table/column creation, configurable schemas, and multiple configuration sources (code, app.config, appsettings.json). The architecture emphasizes separation of concerns through platform abstractions for data access, dependency injection for testability, and strategy patterns for write operations (bulk copy vs. individual inserts). The sink processes log events via Serilib's pipeline, batching them for efficiency unless using the audit sink for critical events. Data is transformed into SQL-compatible values through specialized generators for standard columns (timestamp, level, etc.) and additional custom columns. The system handles type mapping, truncation, and formatting (XML for properties, JSON for log events) while supporting features like hierarchical property resolution, indexed columns, and clustered columnstore indexes for performance. Key strengths include a well-structured plugin architecture with clear extensibility points, comprehensive test coverage across multiple .NET frameworks, and proactive dependency management. The codebase demonstrates solid engineering practices through interface-based design, factory patterns for dependency resolution, and careful handling of edge cases like batch failures and transactional integrity. While supporting legacy configurations adds some complexity, the project maintains active development with recent updates addressing security, performance, and compatibility with newer SQL Client versions.
BentoML is a machine-learning model serving framework and deployment platform. In production it lets developers define inference services via a decorator-based SDK (`@bentoml.service`, `@bentoml.api`), package those services into versioned "Bentos" with locked Python dependencies, and build OCI container images or deploy to Kubernetes, EC2, or BentoCloud. The serving layer supports both HTTP (Starlette/Uvicorn) and gRPC, with adaptive batching, model runners, Prometheus metrics, OpenTelemetry tracing, and pluggable monitoring. A comprehensive CLI (`bentoml serve/build/containerize/deploy`) is the primary operational surface, while the `_bentoml_sdk` and `_bentoml_impl` packages provide the user-facing and internal implementation layers respectively. Architecturally, the project separates concern into model registry, service definition, packaging, server workers, and cloud clients. Model artifacts are persisted in a versioned local store via framework adapters for PyTorch, TensorFlow, Transformers, ONNX, scikit-learn, MLflow, XGBoost, LightGBM, and others. Data flows from trained model artifacts into the registry, get referenced by service code, get bundled by `bentoml build` into self-contained Bento packages, and are served by Circus-managed worker processes. The core request path involves serialization, batching, resource allocation, and process supervision, all implemented in internal modules with generally clean abstractions. The repository is mid-migration from a legacy `bentoml.legacy.Service` API to a newer `_bentoml_sdk`, which creates visible duplication: two HTTP client stacks, multiple protobuf versions, and deprecation shims. This is a real maintenance cost but not a functional blocker; the modern SDK is actively developed, documented, and tested. The repo is clearly an application/framework rather than a data-research project; research-like artifacts are limited to test fixtures, training examples, and ML framework integration tests.
Fetch is a Scala library for simple and efficient data access, built on cats-effect. It provides a monadic abstraction (`Fetch[F, A]`) that automatically optimizes data fetching through batching, caching, deduplication, and parallel execution. Users define data sources by implementing the `DataSource` trait, specifying how to fetch individual identities or batches. The library then composes fetches using standard monadic and applicative combinators, transparently batching requests to the same source and running independent fetches concurrently. It supports custom caches, optional fetches, error handling, and debugging via a separate `fetch-debug` module. The architecture is a pure library with no runtime dependencies beyond cats-effect, making it suitable for both JVM and Scala.js. Key entry points include `Fetch.apply`, `Fetch.run`, `Fetch.runLog`, and `Fetch.runCache`. External dependencies are minimal: cats-effect, cats-core, and scalatest for testing.