v0.7.0 Release Notes

Release Date: August 2025

Cello v0.7.0 is an enterprise-focused release that adds OpenTelemetry distributed tracing, structured health check endpoints, GraphQL support via async-graphql, structured logging, and HTTP/2 and HTTP/3 protocol support. These features bring Cello up to production-grade observability and protocol standards required for modern cloud-native deployments.

---

Highlights

• OpenTelemetry -- Distributed tracing with OTLP export for full request lifecycle visibility
• Health Checks -- Kubernetes-compatible liveness, readiness, and startup probe endpoints
• GraphQL Support -- Schema-first and code-first GraphQL via async-graphql with subscriptions
• Structured Logging -- JSON-formatted logs with trace context injection and configurable outputs
• HTTP/2 & HTTP/3 -- Native support for modern HTTP protocols including QUIC

---

New Features

OpenTelemetry Distributed Tracing

Full OpenTelemetry integration for tracing requests across services.

from cello import App

app = App()

app.enable_opentelemetry(
    service_name="my-service",
    exporter="otlp",
    endpoint="http://localhost:4317",
    sample_rate=0.1,
)

Features:

• OTLP exporter for Jaeger, Zipkin, and other collectors
• Automatic span creation for each request
• Trace context propagation (W3C Trace Context)
• Custom span attributes and events
• Configurable sampling rate
• Baggage propagation across service boundaries

Health Check Endpoints

Kubernetes-compatible health check endpoints for container orchestration.

from cello import App

app = App()

app.enable_health_checks(
    liveness_path="/health/live",
    readiness_path="/health/ready",
    startup_path="/health/startup",
)

# Register custom health checks
@app.health_check("database")
async def check_database():
    return await db.ping()

@app.health_check("redis")
async def check_redis():
    return await redis.ping()

Endpoints:

Endpoint	Purpose	Kubernetes Probe
/health/live	Process is running	livenessProbe
/health/ready	Ready to accept traffic	readinessProbe
/health/startup	Initial startup complete	startupProbe

Response format:

{
    "status": "healthy",
    "checks": {
        "database": {"status": "healthy", "latency_ms": 2},
        "redis": {"status": "healthy", "latency_ms": 1}
    },
    "uptime_seconds": 3600
}

GraphQL Support

Native GraphQL support powered by async-graphql with queries, mutations, and subscriptions.

from cello import App
from cello.graphql import GraphQLSchema, Query, Mutation

app = App()

class UserQuery(Query):
    async def user(self, id: str) -> dict:
        return {"id": id, "name": "Alice"}

    async def users(self) -> list:
        return [{"id": "1", "name": "Alice"}]

schema = GraphQLSchema(query=UserQuery)

app.enable_graphql(schema, path="/graphql")

Features:

• Schema-first and code-first approaches
• Queries, mutations, and subscriptions
• DataLoader for N+1 query prevention
• GraphQL Playground at /graphql
• Subscription support via WebSocket

Structured Logging

JSON-formatted structured logging with automatic trace context injection.

from cello import App

app = App()

app.enable_structured_logging(
    format="json",
    level="info",
    include_trace_id=True,
    output="stdout",
)

Log output:

{
    "timestamp": "2025-08-15T10:30:00Z",
    "level": "info",
    "message": "Request completed",
    "method": "GET",
    "path": "/api/users",
    "status": 200,
    "duration_ms": 3.2,
    "trace_id": "abc123def456",
    "span_id": "789ghi012"
}

HTTP/2 and HTTP/3 Support

Native support for modern HTTP protocols.

from cello import App

app = App()

# HTTP/2 with TLS
app.run(
    host="0.0.0.0",
    port=443,
    tls_cert="cert.pem",
    tls_key="key.pem",
    http2=True,
)

# HTTP/3 (QUIC) - experimental
app.run(
    host="0.0.0.0",
    port=443,
    tls_cert="cert.pem",
    tls_key="key.pem",
    http3=True,
)

Protocol features:

Protocol	Feature	Status
HTTP/2	Multiplexed streams	Stable
HTTP/2	Server push	Stable
HTTP/2	Header compression (HPACK)	Stable
HTTP/3	QUIC transport	Experimental
HTTP/3	0-RTT connection resumption	Experimental

---

Improvements

Performance

• Improved middleware chain execution through better pre-computation
• Reduced memory allocation in request context handling
• Faster header parsing for common header names

Deployment

• Kubernetes manifests with full liveness, readiness, and startup probe examples
• Docker multi-stage build documentation for optimized container images
• Service mesh guide for Istio and Envoy integration

Developer Experience

• Better debug logging with request lifecycle tracing
• Improved error messages for misconfigured OpenTelemetry exporters
• GraphQL Playground for interactive query testing

---

Breaking Changes

None. This release is fully backwards compatible with v0.6.0.

---

Bug Fixes

• Fixed middleware chain not preserving order for equal-priority middleware
• Fixed WebSocket ping/pong frame handling under high load
• Fixed session cookie rotation not updating expiry time
• Fixed CORS preflight caching not respecting Access-Control-Max-Age

---

Dependencies Added

Dependency	Version	Purpose
opentelemetry	0.21	Distributed tracing
quinn	0.10	HTTP/3 / QUIC protocol
h2	0.4	HTTP/2 protocol
async-graphql	6.0	GraphQL engine

---

Migration from v0.6.0

1. Update your dependency:

   pip install --upgrade cello-framework
   

2. No code changes required. All new features are opt-in.

3. To enable new features:

   app.enable_opentelemetry(...)
   app.enable_health_checks(...)
   app.enable_graphql(schema, ...)
   app.enable_structured_logging(...)
   

---

Contributors

Thanks to all contributors who made this release possible!

---

Full Changelog

See the complete changelog for all changes in this release.