# middleapi/orpc

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/middleapi-orpc).**

4,862 stars · 128 forks · TypeScript · mit

## Links

- GitHub: https://github.com/middleapi/orpc
- Homepage: https://orpc.dev
- awesome-repositories: https://awesome-repositories.com/repository/middleapi-orpc.md

## Topics

`api` `bunjs` `cloudflare-worker` `contract-first` `denojs` `next-js` `nodejs` `openapi` `pinia-vuejs` `react` `rpc-api` `solidjs` `svelte` `tanstack` `typesafe` `typescript` `vue`

## Description

orpc is a contract-first API development framework for TypeScript that starts with a shared contract definition and generates type-safe clients and servers from that single source of truth. It guarantees end-to-end type safety, meaning inputs, outputs, errors, and streaming data are all checked at compile time across the client–server boundary.

What distinguishes orpc from typical RPC frameworks is its ability to export contracts as OpenAPI specifications, to optimize server-side rendering by calling API handlers directly inside the server process, and to support real‑time bidirectional communication over WebSocket and server‑sent events. It also provides primitives for inter‑process messaging across workers, Electron processes, and browser scripts, as well as data fetching and mutation hooks that integrate with frontend query libraries like TanStack Query.

Beyond its core contract definition and client generation, orpc offers middleware pipelines, input/output schema validation (using Zod, Valibot, or ArkType), distributed tracing, structured logging, security plugins (CORS, CSRF, rate limiting, encryption), and integrations with many web frameworks including Next.js, Nuxt, Hono, Express, Fastify, Astro, and Solid Start. The framework is available as an npm package and includes tooling for automatic router generation, CLI generation from API definitions, and testing utilities for isolated procedure testing and contract mocking.

## Tags

### Software Engineering & Architecture

- [API Contract Definitions](https://awesome-repositories.com/f/software-engineering-architecture/api-contract-definitions.md) — Declares the type contract for a single API procedure, specifying input and output types without implementation details and serving as a single source of truth. ([source](https://orpc.dev/docs/contract-first/define-contract))
- [Contract-First API Frameworks](https://awesome-repositories.com/f/software-engineering-architecture/contract-first-server-implementations/contract-first-api-frameworks.md) — An API design tool that starts with a shared contract and produces server implementation and client code from a single source of truth.
- [Contract-First Type Safety](https://awesome-repositories.com/f/software-engineering-architecture/contract-first-server-implementations/contract-first-type-safety.md) — The entire API is defined as a contract first, and both server and client derive types from it, ensuring compile-time safety across the boundary.
- [End-to-End Type Safety Frameworks](https://awesome-repositories.com/f/software-engineering-architecture/end-to-end-type-safety-frameworks.md) — Guarantees end-to-end type safety for inputs, outputs, errors, and streaming across client-server boundary. ([source](https://orpc.dev/))
- [Type-Based Contract Validation](https://awesome-repositories.com/f/software-engineering-architecture/api-contract-definitions/api-contract-linting/type-based-contract-validation.md) — Enforces contract types at compile time when building server-side logic. ([source](https://cdn.jsdelivr.net/gh/middleapi/orpc@main/README.md))
- [Contract Router Organizations](https://awesome-repositories.com/f/software-engineering-architecture/api-contract-definitions/contract-router-organizations.md) — Groups multiple procedure contracts into a structured hierarchy for manageable API definition. ([source](https://orpc.dev/docs/contract-first/define-contract))
- [Runtime Contract Validation](https://awesome-repositories.com/f/software-engineering-architecture/api-contract-definitions/runtime-contract-validation.md) — Checks input and output data against Zod, Valibot, or ArkType schemas defined in the contract. ([source](https://cdn.jsdelivr.net/gh/middleapi/orpc@main/README.md))
- [Contract-First Server Implementations](https://awesome-repositories.com/f/software-engineering-architecture/contract-first-server-implementations.md) — Implements server procedures from shared contracts with compile-time type enforcement. ([source](https://orpc.dev/docs/contract-first/implement-contract))
- [Schema-Driven Validations](https://awesome-repositories.com/f/software-engineering-architecture/data-validation-schemas/schema-driven-validations.md) — Input and output data is validated at runtime using Zod, Valibot, or ArkType schemas declared in the contract.
- [Server Action Integrations](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/framework-specific-integrations/next-js-integrations/server-action-integrations.md) — Invokes type-safe procedures from server actions without additional configuration. ([source](https://orpc.dev/docs/adapters/next))
- [Durable Iterator Definitions](https://awesome-repositories.com/f/software-engineering-architecture/api-contract-definitions/durable-iterator-definitions.md) — Defines a typed interface for durable iterator objects to ensure type safety between client and server. ([source](https://orpc.dev/docs/integrations/durable-iterator))
- [Router-to-Contract Converters](https://awesome-repositories.com/f/software-engineering-architecture/api-contract-definitions/router-to-contract-converters.md) — Converts a router definition into a contract object for sharing with clients, stripping lazy routes and minifying payloads. ([source](https://orpc.dev/docs/contract-first/router-to-contract))
- [API Error Handling Patterns](https://awesome-repositories.com/f/software-engineering-architecture/api-error-handling-patterns.md) — Preserves error types across the client-server boundary for type-safe error handling. ([source](https://orpc.dev/docs/client/error-handling))
- [API Handler Mountings](https://awesome-repositories.com/f/software-engineering-architecture/component-port-definitions/module-registration/nuxt-module-registrations/api-handler-mountings.md) — Mounts a type-safe API handler inside Nuxt server routes using file-based routing. ([source](https://orpc.dev/docs/adapters/nuxt))
- [Monorepo Type Safety Structures](https://awesome-repositories.com/f/software-engineering-architecture/end-to-end-type-safety-frameworks/monorepo-type-safety-structures.md) — Maintains end-to-end type safety across projects by separating server packages and using TypeScript Project References. ([source](https://orpc.dev/docs/best-practices/monorepo-setup))
- [Validation Error Aggregators](https://awesome-repositories.com/f/software-engineering-architecture/error-handling/validation-error-aggregators.md) — Validates API inputs and returns structured error messages on failure. ([source](https://orpc.dev/docs/advanced/validation-errors))
- [Type-Safe Context Injections](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/dependency-injection/type-safe-context-injections.md) — Supplies required dependencies explicitly or dynamically through middleware in a type-safe manner. ([source](https://orpc.dev/docs/context))
- [Mock Implementations](https://awesome-repositories.com/f/software-engineering-architecture/metadata-attachments/procedure/mock-implementations.md) — Replaces actual procedure implementations with fake counterparts to isolate logic and simulate scenarios. ([source](https://orpc.dev/docs/advanced/testing-mocking))
- [Rate Limiting](https://awesome-repositories.com/f/software-engineering-architecture/request-throttling/rate-limiting.md) — Limits the number of requests a client can make within a time window and adds standard rate-limiting headers. ([source](https://orpc.dev/docs/helpers/ratelimit))

### Web Development

- [Type-Safe Client Generators](https://awesome-repositories.com/f/web-development/api-client-generators/type-safe-client-generators.md) — Generates a type-safe client that mirrors the server contract with full auto-completion. ([source](https://orpc.dev/docs/getting-started))
- [Contract-First Specifications](https://awesome-repositories.com/f/web-development/api-management-tools/api-development-management/api-documentation/contract-first-specifications.md) — Defines API contracts with shared schemas for end-to-end type safety between client and server.
- [Type-Safe API Frameworks](https://awesome-repositories.com/f/web-development/type-safe-api-frameworks.md) — A framework that defines typed API procedures with input/output validation and generates type-safe clients for end-to-end safety.
- [API Procedure Routers](https://awesome-repositories.com/f/web-development/api-procedure-routers.md) — Provides structured routers for accessing typed API procedures by path. ([source](https://orpc.dev/docs/client/server-side))
- [Type Inference](https://awesome-repositories.com/f/web-development/api-procedure-routers/type-inference.md) — Extracts the input, output, and context types for every procedure in a router statically. ([source](https://orpc.dev/docs/router))
- [Multi-Platform Exposures](https://awesome-repositories.com/f/web-development/api-servers/multi-platform-exposures.md) — Serves the defined API contract over HTTP using a server runtime, supporting multiple platforms. ([source](https://orpc.dev/docs/getting-started))
- [API Router Generators](https://awesome-repositories.com/f/web-development/automatic-routers/api-router-generators.md) — Uses file structure or database schemas to produce fully-featured routers with validation and services. ([source](https://orpc.dev/docs/ecosystem))
- [Context Injectors](https://awesome-repositories.com/f/web-development/backend-development/request-response-handling/http-response-handling/response-metadata-accessors/response-header-modifiers/context-injectors.md) — Injects a headers object into the request context for modifying outbound HTTP response headers. ([source](https://orpc.dev/docs/plugins/response-headers))
- [Type-Safe Definitions](https://awesome-repositories.com/f/web-development/client-side-execution-environments/client-side-tool-execution/server-side-action-registries/type-safe-definitions.md) — Converts a typed procedure into a server action callable from client components with full type safety and structured error handling. ([source](https://orpc.dev/docs/server-action))
- [Server Action Hooks](https://awesome-repositories.com/f/web-development/frontend-development-tools/frontend-frameworks/component-authoring/react-ecosystem/react-hooks/server-action-hooks.md) — Provides React hooks to call server actions from client components with basic invocation and optimistic updates. ([source](https://orpc.dev/docs/server-action))
- [Frontend Query Library Hooks](https://awesome-repositories.com/f/web-development/frontend-query-library-hooks.md) — Provides typed hooks for frontend query libraries like TanStack Query for type-safe data fetching. ([source](https://orpc.dev/docs/comparison))
- [HTTP RPC Transports](https://awesome-repositories.com/f/web-development/http-rpc-transports.md) — Sends type-safe RPC requests over HTTP with end-to-end type safety. ([source](https://orpc.dev/docs/client/rpc-link))
- [Query Library Configuration Generators](https://awesome-repositories.com/f/web-development/query-library-configuration-generators.md) — Generates type-safe options for TanStack Query hooks with support for advanced data patterns. ([source](https://orpc.dev/docs/integrations/tanstack-query))
- [Real-Time Communication](https://awesome-repositories.com/f/web-development/real-time-communication.md) — Handles WebSocket connections and SSE streaming for bidirectional, live data exchange. ([source](https://orpc.dev/docs/comparison))
- [Remote Data Fetching Hooks](https://awesome-repositories.com/f/web-development/remote-data-fetching-hooks.md) — Generates type-safe query configurations that integrate with frontend data fetching hooks for reading API resources. ([source](https://orpc.dev/docs/integrations/pinia-colada))
- [Remote Procedure Calls](https://awesome-repositories.com/f/web-development/remote-procedure-calls.md) — Provides type-safe remote procedure calls over HTTP with native data type preservation. ([source](https://orpc.dev/docs/advanced/rpc-protocol))
- [Ordered Middleware Pipelines](https://awesome-repositories.com/f/web-development/request-middleware-pipelines/service-middleware-pipelines/ordered-middleware-pipelines.md) — An ordered middleware pipeline wraps procedure execution, allowing cross-cutting concerns such as authentication and logging to be inserted at specific points.
- [OpenAPI Publishing](https://awesome-repositories.com/f/web-development/restful-apis/documentation-schemas/openapi-specification-generators/openapi-publishing.md) — Automatically exposes the type-safe API contract as an OpenAPI-compliant REST interface. ([source](https://orpc.dev/docs/openapi/getting-started))
- [Type-Safe RPC Engines](https://awesome-repositories.com/f/web-development/restful-apis/documentation-schemas/openapi-specification-generators/openapi-publishing/type-safe-rpc-engines.md) — An RPC server that exports OpenAPI specifications and can serve contracts over HTTP while preserving native type safety.
- [In-Process API Call Bypasses](https://awesome-repositories.com/f/web-development/server-side-rendering-frameworks/in-process-api-call-bypasses.md) — Bypasses HTTP requests during server-side rendering by using a local server-side client to reduce latency. ([source](https://orpc.dev/docs/adapters/tanstack-start))
- [Shared Router Client Reusers](https://awesome-repositories.com/f/web-development/ssr-data-fetching/shared-router-client-reusers.md) — Shares a router client across SSR requests to avoid redundant network calls and ensure consistent data types. ([source](https://orpc.dev/docs/best-practices/optimize-ssr))
- [Type-Safe API Clients](https://awesome-repositories.com/f/web-development/type-safe-api-clients.md) — Provides recursive type inference from client objects for end-to-end type safety. ([source](https://orpc.dev/docs/client/client-side))
- [Procedure Definitions](https://awesome-repositories.com/f/web-development/type-safe-api-frameworks/procedure-definitions.md) — Encapsulates an API endpoint with input/output validation and middleware chaining for extensible communication. ([source](https://orpc.dev/docs/procedure))
- [Type-Safe Mutation Configurations](https://awesome-repositories.com/f/web-development/type-safe-mutation-configurations.md) — Generates type-safe mutation configurations for writing API resources through frontend mutation hooks. ([source](https://orpc.dev/docs/integrations/pinia-colada))
- [Web Framework Integrations](https://awesome-repositories.com/f/web-development/web-framework-integrations.md) — Processes API requests within a web framework routing system, executing them with any supported handler type. ([source](https://orpc.dev/docs/adapters/tanstack-start))
- [Pipeline Hooks](https://awesome-repositories.com/f/web-development/web-server-extensions/pipeline-hooks.md) — Adds custom logic to server handlers by hooking into request processing stages from parsing to formatting. ([source](https://orpc.dev/docs/advanced/building-custom-plugins))
- [Client-Side Input Validators](https://awesome-repositories.com/f/web-development/client-side-input-validators.md) — Validates user input on the client side using shared schemas before sending requests. ([source](https://orpc.dev/docs/plugins/request-validation))
- [Automatic Revalidation](https://awesome-repositories.com/f/web-development/data-fetching-caching/data-fetching/automatic-revalidation.md) — Fetches data from a remote API with built-in caching and automatic revalidation to keep the UI updated. ([source](https://orpc.dev/docs/integrations/react-swr))
- [Type-Safe Query Error Detection](https://awesome-repositories.com/f/web-development/error-handling/type-safe-query-error-detection.md) — Ships built-in helpers for detecting defined error types within query and mutation results for precise handling. ([source](https://orpc.dev/docs/integrations/tanstack-query))
- [Resumable Event Streams](https://awesome-repositories.com/f/web-development/event-streaming/resumable-event-streams.md) — Persists events for configurable durations so clients resume missed events after reconnection. ([source](https://orpc.dev/docs/integrations/durable-iterator))
- [Durable Event Iterators](https://awesome-repositories.com/f/web-development/event-streaming/resumable-event-streams/hibernating-event-iterators/durable-event-iterators.md) — Streaming responses are delivered as durable iterators that support reconnection, hibernation, and event ID resumption for reliability.
- [Express Integrations](https://awesome-repositories.com/f/web-development/express-integrations.md) — Mounts typed API handlers as middleware on Express.js for request processing. ([source](https://orpc.dev/docs/adapters/express))
- [Retry and Backoff Logic](https://awesome-repositories.com/f/web-development/http-client-wrappers/retry-and-backoff-logic.md) — Implements automatic retry with exponential backoff for failed client requests. ([source](https://orpc.dev/docs/plugins/client-retry))
- [Inter-Thread Communication](https://awesome-repositories.com/f/web-development/inter-thread-communication.md) — Enforces type-safe communication between worker threads by binding message port adapters to shared contract definitions. ([source](https://orpc.dev/docs/adapters/worker-threads))
- [Global Middleware Registration](https://awesome-repositories.com/f/web-development/middleware/global-middleware-registration.md) — Adds a middleware step to every route in a router so cross-cutting concerns run once per request. ([source](https://orpc.dev/docs/router))
- [Composable Permission Enforcers](https://awesome-repositories.com/f/web-development/request-mappings/type-safe/composable-permission-enforcers.md) — Enforces permissions and authorization rules in a composable, type-safe manner across the application. ([source](https://orpc.dev/docs/ecosystem))
- [Request-Response Interceptors](https://awesome-repositories.com/f/web-development/request-response-interceptors.md) — Provides hooks to inspect, transform, or abort RPC requests and responses. ([source](https://orpc.dev/docs/client/rpc-link))
- [Response Validation](https://awesome-repositories.com/f/web-development/response-validation.md) — Validates server responses against the contract schema to ensure type safety. ([source](https://orpc.dev/docs/plugins/response-validation))
- [Route Handlers](https://awesome-repositories.com/f/web-development/route-handlers.md) — Mounts a type-safe API handler in a route handler to expose the API through the application routing system. ([source](https://orpc.dev/docs/adapters/next))
- [Solid Start Handler Mountings](https://awesome-repositories.com/f/web-development/solid-start-handler-mountings.md) — Exposes a type-safe API handler as a route in Solid Start to process incoming requests. ([source](https://orpc.dev/docs/adapters/solid-start))
- [TanStack Query SSR Integrations](https://awesome-repositories.com/f/web-development/ssr-data-fetching/tanstack-query-ssr-integrations.md) — Combines server-side rendering with a data-fetching library for asynchronous data loading across server and client. ([source](https://orpc.dev/docs/best-practices/optimize-ssr))
- [Query Cache Hydration](https://awesome-repositories.com/f/web-development/ssr-hydration-helpers/query-cache-hydration.md) — Extends the serializer to include query caches, enabling seamless server-side rendering without refetching. ([source](https://orpc.dev/docs/integrations/tanstack-query))
- [RPC Over WebSocket](https://awesome-repositories.com/f/web-development/websockets/rpc-over-websocket.md) — Makes remote procedure calls from client to server over the same persistent WebSocket used for event streaming. ([source](https://orpc.dev/docs/integrations/durable-iterator))

### Data & Databases

- [Router Type Inference](https://awesome-repositories.com/f/data-databases/data-type-definitions/schema-type-synchronization/cross-stack-type-contracts/router-type-inference.md) — Automatically derives the expected input and output types from a contract router for end-to-end type safety. ([source](https://orpc.dev/docs/contract-first/define-contract))
- [Payload Serialization](https://awesome-repositories.com/f/data-databases/data-transformation/payload-serialization.md) — Serializes JSON payloads for RPC with support for native data types and type safety. ([source](https://orpc.dev/docs/advanced/rpc-json-serializer))

### Development Tools & Productivity

- [OpenAPI Specification Generators](https://awesome-repositories.com/f/development-tools-productivity/openapi-configurations/documentation-generators/openapi-specification-generators.md) — Exports API contracts as OpenAPI documents for documentation and third-party client generation.
- [OpenAPI Router Exposure](https://awesome-repositories.com/f/development-tools-productivity/openapi-configurations/documentation-generators/openapi-specification-generators/openapi-router-exposure.md) — Converts a router into a format that supports OpenAPI specification generation and request handling. ([source](https://orpc.dev/docs/openapi/integrations/trpc))
- [Client Middleware Extensions](https://awesome-repositories.com/f/development-tools-productivity/api-client-libraries/llm-clients/client-middleware-extensions.md) — Allows extending client requests and responses with middleware for authentication, logging, and retry. ([source](https://orpc.dev/docs/advanced/building-custom-plugins))

### Networking & Communication

- [Real-time Event Streams](https://awesome-repositories.com/f/networking-communication/real-time-event-streams.md) — Streams server-sent events or WebSocket messages using type-safe event iterators and pub-sub. ([source](https://orpc.dev/docs/helpers/publisher))
- [Remote Procedure Calls](https://awesome-repositories.com/f/networking-communication/remote-procedure-calls.md) — Invokes server procedures with identical syntax and type safety as local function calls. ([source](https://orpc.dev/docs/client/client-side))
- [Type-Safe Remote Calls](https://awesome-repositories.com/f/networking-communication/remote-procedure-calls/type-safe-remote-calls.md) — Enables remote function calls over HTTP or WebSocket with full type inference and validation.
- [Procedure Execution Interception](https://awesome-repositories.com/f/networking-communication/remote-procedure-execution/procedure-execution-interception.md) — Hooks into procedure execution to run custom logic before, after, or around the handler. ([source](https://orpc.dev/docs/middleware))
- [Remote Procedure Invocation Systems](https://awesome-repositories.com/f/networking-communication/remote-procedure-invocation-systems.md) — Enables type-safe invocation of server procedures with full autocomplete from the client. ([source](https://orpc.dev/docs/getting-started))
- [Context Injectors](https://awesome-repositories.com/f/networking-communication/request-header-configuration/context-injectors.md) — Injects request headers into the context so handlers can read them through a consistent interface. ([source](https://orpc.dev/docs/plugins/request-headers))
- [Type-Safe Real-Time RPC Platforms](https://awesome-repositories.com/f/networking-communication/websocket-rpc-interfaces/type-safe-real-time-rpc-platforms.md) — A platform supporting WebSocket and SSE streaming for bidirectional, live data exchange with full type safety and reconnection support.
- [Contract-Based File Uploads](https://awesome-repositories.com/f/networking-communication/api-integration-frameworks/api-management-integration/api-integrations/file-upload-apis/contract-based-file-uploads.md) — Sends files alongside other data in a structured API call, supporting File and Blob objects. ([source](https://orpc.dev/docs/file-upload-download))
- [Isomorphic HTTP Clients](https://awesome-repositories.com/f/networking-communication/isomorphic-http-clients.md) — Configures RPC clients with separate settings for browser and server environments. ([source](https://orpc.dev/docs/adapters/tanstack-start))
- [JavaScript-Native RPC Protocols](https://awesome-repositories.com/f/networking-communication/javascript-native-rpc-protocols.md) — Implements a custom RPC protocol that preserves JavaScript native types for type-safe communication. ([source](https://orpc.dev/docs/rpc-handler))
- [Per-Request Context Providers](https://awesome-repositories.com/f/networking-communication/per-request-context-providers.md) — Provides dynamic per-request context passing to customize procedure behavior. ([source](https://orpc.dev/docs/client/server-side))
- [Token Streaming](https://awesome-repositories.com/f/networking-communication/real-time-event-streams/token-streaming.md) — Streams AI model tokens token by token for real-time display in client applications. ([source](https://orpc.dev/docs/examples/openai-streaming))
- [In-Process Procedure Invocations](https://awesome-repositories.com/f/networking-communication/remote-procedure-invocation-systems/in-process-procedure-invocations.md) — Invokes server procedures in-process for optimized server-side rendering. ([source](https://orpc.dev/docs/client/server-side))
- [Server-Sent Events](https://awesome-repositories.com/f/networking-communication/server-sent-events.md) — Reads server-sent events by iterating over event iterators as async generators with lifecycle callbacks. ([source](https://orpc.dev/docs/client/event-iterator))
- [Type-Safe Cross-Process Bridges](https://awesome-repositories.com/f/networking-communication/transport-abstractions/type-safe-cross-process-bridges.md) — Multiple communication channels (HTTP, WebSocket, MessagePort, Electron) are abstracted behind a common bridge interface enabling type-safe cross-process messaging.
- [WebSocket RPC Interfaces](https://awesome-repositories.com/f/networking-communication/websocket-rpc-interfaces.md) — Opens a persistent, low-latency WebSocket connection for bidirectional remote procedure calls. ([source](https://orpc.dev/docs/adapters/websocket))

### Programming Languages & Runtimes

- [Implicit Context Passing](https://awesome-repositories.com/f/programming-languages-runtimes/implicit-context-passing.md) — Attaches runtime context to each procedure call to dynamically alter link behavior. ([source](https://orpc.dev/docs/client/rpc-link))

### User Interface & Experience

- [In-Process SSR Data Fetching](https://awesome-repositories.com/f/user-interface-experience/content-rendering-components/server-side-data-fetching/in-process-ssr-data-fetching.md) — Optimizes SSR by calling API handlers directly inside the server process, eliminating extra HTTP requests.

### Part of an Awesome List

- [Fastify Integrations](https://awesome-repositories.com/f/awesome-lists/devtools/fastify-integrations.md) — Mounts any type-safe API handler on Fastify, leveraging its request parsing and plugin architecture. ([source](https://orpc.dev/docs/adapters/fastify))

### Content Management & Publishing

- [Environment-Aware Configurations](https://awesome-repositories.com/f/content-management-publishing/documentation-metadata-configurations/environment-aware-configurations.md) — Configures RPC links to work seamlessly in both server and browser environments. ([source](https://orpc.dev/docs/adapters/next))

### DevOps & Infrastructure

- [Security Plugin Packs](https://awesome-repositories.com/f/devops-infrastructure/release-automation/plugin-extensibility/security-plugin-packs.md) — Applies ready-to-use plugins for CORS, CSRF protection, retry logic, and other cross-cutting concerns. ([source](https://orpc.dev/docs/comparison))

### System Administration & Monitoring

- [Distributed Tracing Instrumentation](https://awesome-repositories.com/f/system-administration-monitoring/distributed-tracing-instrumentation.md) — The library instruments client and server calls to propagate trace context and capture spans, enabling end-to-end observability without manual setup.