GoFr Framework

GoFr is an opinionated microservice development framework optimized for Kubernetes deployment and observability. Key features include:

• Observability: Built-in support for Logs, Traces, and Metrics.
• Communication: REST standards, gRPC support, HTTP services with Circuit Breaker, Websockets, and Pub/Sub.
• Middleware: Inbuilt Auth middleware and support for custom middleware.
• Data Management: Database migrations, health checks for all datasources, and abstracted file systems.
• Operational Tools: Cron jobs, Swagger rendering, and the ability to change log levels remotely without restarting the service.

Unlike Rails, where observability is often wired manually, GoFr provides built-in observability:

• Traces: Automatically emits OpenTelemetry traces.
• Metrics: Prometheus metrics are available at the /metrics endpoint.
• Logs: Structured JSON logs including trace IDs.
• Health Checks: Available at /.well-known/health.
• Runtime Log Control: Log levels can be changed at runtime via a remote log-level endpoint.

GoFr includes several built-in capabilities for production-ready microservices:

• Logging: Level-based logging support for effective debugging and monitoring.
• Response Types: Support for various response types, including JSON and FILE.
• Monitoring: Built-in Health check and Readiness monitoring to ensure continuous service availability.
• Metrics: Metrics exposure via Prometheus for monitoring and analysis.
• Tracing: Tracing capabilities to track user request progress using traceable spans.

GoFr and Fiber are both open-source frameworks with different design philosophies:

• Fiber is an Express-inspired HTTP framework built on fasthttp. It is optimized for high raw HTTP throughput and is ideal for developers coming from a Node.js background. However, because it uses fasthttp, it is not natively compatible with the standard net/http library without using an adapter.
• GoFr is built on the standard net/http library, ensuring full compatibility with the Go ecosystem. It is a broader production stack that bundles HTTP routing with built-in support for gRPC, GraphQL, Pub/Sub, cron jobs, migrations, and circuit breakers. It also provides out-of-the-box observability (OpenTelemetry and Prometheus) and auto-instrumented datasource clients.

The Publisher-Subscriber pattern in GoFr is used for asynchronous communication between decoupled entities (different applications or instances of the same application). This pattern allows components to exchange messages without knowing each other's identities, enhancing system flexibility and scalability.

GoFr supports multiple message brokers to implement this pattern, including:

• Apache Kafka
• Google PubSub
• MQTT
• NATS JetStream
• Redis Pub/Sub
• Azure Event Hubs
• Amazon SQS

GoFr provides a uniform API for interacting with various storage backends, allowing you to read and write files using the same set of methods regardless of the underlying system. This abstraction hides the implementation details of different storage providers.

Supported Backends:

• Local Disk: Initialized by default and accessible via the context.
• FTP/SFTP: For traditional file transfer protocols.
• Cloud Storage: AWS S3, Google Cloud Storage (GCS), and Azure File Storage.
• S3-Compatible: Cloudflare R2, MinIO, DigitalOcean Spaces, and others.

GoFr provides built-in observability for GraphQL via OpenTelemetry and Prometheus metrics.

Tracing

• Root Span: graphql-request for every request.
• Resolver Spans: Nested spans for each field (e.g., graphql-resolver-user).
• Attributes: graphql.operation_name and graphql.operation_type are automatically attached.

Metrics

Metrics are tagged by operation_name, type (query/mutation), and status (success or error).

• app_graphql_operations_total: Total operations received.
• app_graphql_error_total: Total operations resulting in errors (validation or resolver errors).
• app_graphql_request_duration: Histogram of request lifecycle in seconds.

Note on Status Labels: In GraphQL metrics, success means the request returned no errors in the errors array, even if the HTTP status was 200 OK.

When Kubernetes terminates a pod, it sends a SIGTERM signal. GoFr's app.Run() listens for this signal and begins a graceful shutdown by stopping the acceptance of new requests while allowing in-flight requests to complete.

To ensure GoFr has enough time to drain these requests, you must set the terminationGracePeriodSeconds in your Pod specification to a value higher than your longest expected in-flight request. A value of 45 seconds is a common starting point for standard APIs.

Deployment Configuration:

spec:
  template:
    spec:
      terminationGracePeriodSeconds: 45
      containers:
        - name: orders
          # ...