awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
twitter avatar

twitter/finagle

0
View on GitHub↗
8,867 stars·1,436 forks·Scala·Apache-2.0·20 viewstwitter.github.io/finagle↗

Finagle

Finagle is a distributed service mesh and fault-tolerant remote procedure call framework. It provides a protocol-agnostic network library that implements a consistent interface for different network standards, including HTTP and Thrift.

The project distinguishes itself by integrating a fault tolerance library that prevents cascading failures through circuit breaking and timeout management. It also implements a distributed tracing system to track requests across network boundaries and visualize call graphs.

The framework covers several core capability areas, including dynamic service discovery, load balancing, and the propagation of request-scoped metadata across asynchronous execution boundaries. It further includes tools for service performance monitoring, TLS connection security, and managed MySQL query execution.

Features

  • Service Meshes - Provides a comprehensive service mesh for managing service-to-service communication, load balancing, and discovery in distributed systems.
  • RPC Frameworks - Provides a high-performance RPC framework with integrated fault tolerance and scalable traffic handling.
  • Asynchronous Request Handlers - Utilizes non-blocking I/O to efficiently manage high volumes of concurrent network request-response operations.
  • Concurrent Protocol Managers - Implements uniform APIs to manage high volumes of simultaneous network connections across multiple protocols.
  • Distributed Trace Propagation - Propagates trace IDs and security tokens across service boundaries to maintain distributed request context.
  • Distributed Tracing - Implements a system for tracking requests across network boundaries to visualize call graphs and analyze latency.
  • Dynamic Service Discovery - Resolves remote service addresses at runtime using a registry to distribute traffic across dynamic node sets.
  • Protocol-Agnostic Interfaces - Implements a consistent, protocol-agnostic interface for various network standards including HTTP and Thrift.
  • Protocol-Agnostic Transport Layers - Implements a consistent, protocol-agnostic core that abstracts communication across different network standards.
  • Circuit Breakers - Implements circuit breakers to automatically stop requests to failing services and prevent cascading crashes.
  • Distributed Service Coordination - Provides a request-response framework that coordinates communication and service discovery across distributed nodes.
  • Fault Tolerance - Ensures RPC resilience by preventing cascading failures through circuit breaking and timeout management.
  • Fault Tolerance Implementation - Provides a library to prevent cascading failures using circuit breaking and timeout management.
  • Client-Side Balancing - Implements client-side load balancing to distribute outgoing requests across available servers based on health checks.
  • Request Context Propagation - Carries request-scoped state and metadata across asynchronous execution boundaries in distributed call chains.
  • Apache Thrift Integrations - Provides full support for Apache Thrift binary protocols and interface definition language generated code.
  • Middleware-Based Request Pipelines - Processes network requests through modular filter chains that handle timeouts, retries, and metadata.
  • HTTP Service Frameworks - Provides specialized tools to construct network servers and clients for standard HTTP communication.
  • Secure Connection Handlers - Secures network traffic using TLS encryption with support for explicit and opportunistic negotiation.
  • Metric and Performance Monitors - Records and tracks standardized performance metrics for network services.
  • Service Mesh Performance Monitors - Tracks performance metrics and health statistics specifically for service mesh workloads and network paths.
  • Application Health Monitors - Exposes diagnostic metrics and statistics for clients and servers to monitor operational health.
  • Databases and Data - Fault-tolerant RPC system for distributed services.
  • RPC Frameworks - Fault-tolerant, protocol-agnostic RPC system.

Star history

Star history chart for twitter/finagleStar history chart for twitter/finagle

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Frequently asked questions

What does twitter/finagle do?

Finagle is a distributed service mesh and fault-tolerant remote procedure call framework. It provides a protocol-agnostic network library that implements a consistent interface for different network standards, including HTTP and Thrift.

What are the main features of twitter/finagle?

The main features of twitter/finagle are: Service Meshes, RPC Frameworks, Asynchronous Request Handlers, Concurrent Protocol Managers, Distributed Trace Propagation, Distributed Tracing, Dynamic Service Discovery, Protocol-Agnostic Interfaces.

Which projects share features with twitter/finagle?

Projects with overlapping indexed features include: moleculerjs/moleculer — Moleculer is a Node.js microservices framework designed for building distributed systems. It functions as a… smallnest/rpcx — rpcx is a high-performance remote procedure call framework for building scalable microservices in Go. It functions as… linkerd/linkerd2 — This project is a service mesh platform designed to manage, secure, and observe service-to-service communication… quarkusio/quarkus — Quarkus is a Kubernetes-native Java framework designed for building high-performance, memory-efficient applications.… netflix/ribbon — Ribbon is a client-side load balancer and RPC communication library designed for inter-process communication. It… line/armeria — Armeria is a Netty-based microservice framework used for building high-performance asynchronous services. It functions…

Projects sharing features with Finagle

These projects share indexed features with Finagle. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • moleculerjs/moleculermoleculerjs avatar

    moleculerjs/moleculer

    6,373View on GitHub↗

    Moleculer is a Node.js microservices framework designed for building distributed systems. It functions as a distributed service broker, task orchestrator, and service mesh framework, enabling a decentralized architecture with built-in service discovery and load balancing. The project differentiates itself through a pluggable transport layer supporting protocols such as NATS, Redis, TCP, and Kafka, as well as a dedicated microservices API gateway that maps external HTTP and WebSocket requests to internal service actions. It includes built-in fault tolerance mechanisms, including circuit breake

    JavaScript
    View on GitHub↗6,373
  • smallnest/rpcxsmallnest avatar

    smallnest/rpcx

    8,295View on GitHub↗

    rpcx is a high-performance remote procedure call framework for building scalable microservices in Go. It functions as a binary protocol RPC system and a service mesh, providing the necessary infrastructure for low-latency inter-service communication and distributed cloud environments. The project features a cross-language service gateway that provides an HTTP entry point, allowing clients written in any programming language to invoke Go remote services via protocol translation. It also includes a specialized RPC traffic analyzer for capturing and analyzing binary packets to debug network comm

    Godubbogrpcmicroservice
    View on GitHub↗8,295
  • linkerd/linkerd2linkerd avatar

    linkerd/linkerd2

    11,424View on GitHub↗

    This project is a service mesh platform designed to manage, secure, and observe service-to-service communication within Kubernetes clusters. It functions as a control plane that orchestrates transparent sidecar proxies, which intercept and manage network traffic to provide reliable connectivity for microservices. By automating the injection of these proxies, the platform ensures that infrastructure-level policies are applied consistently across all workloads without requiring manual configuration changes. The platform distinguishes itself through its focus on zero-trust security and cross-clu

    Gocloud-nativegolangkubernetes
    View on GitHub↗11,424
  • quarkusio/quarkusquarkusio avatar

    quarkusio/quarkus

    15,479View on GitHub↗

    Quarkus is a Kubernetes-native Java framework designed for building high-performance, memory-efficient applications. It utilizes ahead-of-time native compilation to transform Java code into standalone, optimized binaries that eliminate the need for a virtual machine, enabling rapid startup and reduced memory consumption. By performing code augmentation during the build phase, it shifts heavy processing tasks away from runtime, ensuring that applications are optimized for cloud-native environments. The framework distinguishes itself through a unified approach to reactive and imperative program

    Javacloud-nativehacktoberfestjava
    View on GitHub↗15,479
Compare all 30 related projects→