awesome-repositories.com
Blog
awesome-repositories.com

Découvrez les meilleurs dépôts open-source grâce à notre recherche par IA.

ExplorerRecherches sélectionnéesAlternatives open sourceLogiciels auto-hébergésBlogPlan du site
ProjetÀ proposNotre méthodologiePresseServeur MCP
Mentions légalesConfidentialitéConditions d'utilisation
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

10 dépôts

Awesome GitHub RepositoriesExecution Error Captures

Mechanisms that capture errors during task execution and route them to dedicated error signals without terminating the main stream.

Distinct from Error Handling: Distinct from Error Handling: focuses on capturing errors from concurrent task execution rather than general error reporting patterns.

Explore 10 awesome GitHub repositories matching web development · Execution Error Captures. Refine with filters or upvote what's useful.

Awesome Execution Error Captures GitHub Repositories

Trouvez les meilleurs dépôts grâce à l'IA.Nous recherchons les dépôts les plus pertinents grâce à l'IA.
  • zalmoxisus/redux-devtools-extensionAvatar de zalmoxisus

    zalmoxisus/redux-devtools-extension

    13,460Voir sur GitHub↗

    This project is a state management inspector and debugging tool for Redux. It provides a browser-based interface for inspecting and modifying application state and actions in real time, serving as an action logger and time travel debugger to troubleshoot application logic. The tool allows users to navigate a chronological history of state changes to replay previous versions of the application or skip specific actions. It also functions as a remote monitoring bridge, streaming Redux state and actions from non-browser environments to a centralized debugging interface. The capability surface in

    Intercepts exceptions thrown during state updates and displays error messages to prevent further invalid actions.

    JavaScriptdebugdevtoolsextension
    Voir sur GitHub↗13,460
  • home-assistant/home-assistant.ioAvatar de home-assistant

    home-assistant/home-assistant.io

    9,466Voir sur GitHub↗

    Home Assistant is a local home automation platform and server that acts as an IoT device orchestrator. It integrates diverse smart home hardware by wrapping third-party APIs into a standardized logic layer and stores all system state and historical statistics on local hardware to eliminate cloud dependencies. The system functions as a Matter IoT controller and an MQTT home automation bridge, allowing for local interoperability between different manufacturers. It features a state-based entity model and an internal event bus that decouple physical device logic from system automation. The platf

    Controls whether an automation sequence halts or continues after an action encounters an error.

    HTMLdocumentationhacktoberfesthass
    Voir sur GitHub↗9,466
  • pixie-io/pixieAvatar de pixie-io

    pixie-io/pixie

    6,467Voir sur GitHub↗

    Pixie is an open-source observability platform for Kubernetes that uses eBPF to automatically capture telemetry data from clusters without requiring any manual instrumentation or code changes. It functions as an eBPF telemetry collector, a continuous application profiler, a network traffic analyzer, and a scriptable telemetry query engine, all within a single Kubernetes-native tool. The platform distinguishes itself through several integrated capabilities. It continuously samples stack traces from compiled-language code to identify CPU performance bottlenecks, visualizing the results as inter

    Views HTTP error rate and resource metrics for individual pods to isolate the source of service errors.

    C++
    Voir sur GitHub↗6,467
  • cri-o/cri-oAvatar de cri-o

    cri-o/cri-o

    5,629Voir sur GitHub↗

    CRI-O is an open-source container runtime that implements the Kubernetes Container Runtime Interface (CRI) to manage container images, pods, and containers on cluster nodes using OCI-compatible runtimes. It serves as a node-level container manager that handles image pulling, container lifecycle, and resource monitoring for Kubernetes clusters, running containers according to the Open Container Initiative specifications. The runtime distinguishes itself through live configuration reloading that applies changes to runtime definitions, registry mirrors, and TLS certificates without restarting th

    Includes verbose status details for pods that have dropped their infra container.

    Go
    Voir sur GitHub↗5,629
  • zerobias/effectorAvatar de zerobias

    zerobias/effector

    4,837Voir sur GitHub↗

    Effector is a reactive state management library and data flow orchestrator designed for building complex, event-driven applications. It models application logic as a directed acyclic graph, where state updates and asynchronous side effects propagate automatically through declarative pipelines. By decoupling business logic from user interface layers, it allows developers to maintain state in independent containers that communicate via standard interfaces, ensuring the system remains framework-agnostic. The library distinguishes itself through its robust support for isolated execution scopes, w

    Logs exceptions occurring during computation branches and halts execution to prevent corrupted state while providing diagnostic information.

    TypeScript
    Voir sur GitHub↗4,837
  • effector/effectorAvatar de effector

    effector/effector

    4,837Voir sur GitHub↗

    Effector is a reactive state management library designed for building complex, event-driven applications. It functions as a data flow engine that models application logic as a directed acyclic graph, ensuring that state updates propagate automatically through interconnected nodes. By utilizing atomic state updates and declarative unit composition, the library maintains data consistency and provides a predictable execution model for managing application state. The project distinguishes itself through its framework-agnostic architecture, which decouples business logic from user interface implem

    Captures errors during asynchronous task execution and routes them to dedicated error signals.

    TypeScriptbusiness-logiceffectorevent-driven
    Voir sur GitHub↗4,837
  • formidablelabs/react-liveAvatar de FormidableLabs

    FormidableLabs/react-live

    4,609Voir sur GitHub↗

    react-live est une suite d'outils pour la transpilation React dans le navigateur, l'édition en direct et la documentation interactive. Elle fournit un composant React pour construire des terrains de jeu (playgrounds) en direct où le code source est transpilé et rendu en temps réel, accompagné d'un éditeur de code en direct qui offre une coloration syntaxique et un retour visuel immédiat. Le projet permet la création de documentation vivante en intégrant des exemples de code React modifiables aux côtés de leur sortie rendue. Il prend en charge l'exécution de balisage modifiable ou de composants fonctionnels, permettant aux utilisateurs de modifier le code et d'observer le comportement résultant instantanément. Le système inclut des capacités pour le rendu de composants dynamiques, la transpilation de code en temps réel et l'injection de dépendances globale. Il dispose également de mécanismes de gestion des erreurs pour détecter et afficher les erreurs de compilation, de syntaxe et d'exécution sans faire planter l'application.

    Captures and renders errors encountered during the transpilation or execution of live code.

    TypeScriptcomponent-playgroundlivereact
    Voir sur GitHub↗4,609
  • zio/zioAvatar de zio

    zio/zio

    4,347Voir sur GitHub↗

    ZIO is a functional effect system for the JVM that models asynchronous and concurrent programs as pure, composable values with typed error handling and dependency injection. Its core identity is built on fiber-based concurrency, where lightweight, non-blocking fibers execute millions of concurrent tasks with structured lifecycle management, and a dual-channel error model that separates expected business failures from unexpected system defects at compile time. The system provides effect-typed dependency injection through a layer-based dependency graph, pull-based reactive stream processing with

    Inspects the outcome of an effect as either a success value or a failure with a full cause chain.

    Scalaasynchronicityasynchronousasynchronous-programming
    Voir sur GitHub↗4,347
  • ochinchina/supervisordAvatar de ochinchina

    ochinchina/supervisord

    4,262Voir sur GitHub↗

    Ce projet est un superviseur de processus Go conçu pour démarrer et surveiller plusieurs programmes en arrière-plan avec redémarrages automatiques et gestion du cycle de vie. Il fonctionne comme un système pour coordonner l'exécution de démons, assurant une opération continue via une configuration centrale. Le superviseur se distingue par de multiples interfaces d'administration à distance, incluant une API REST de gestion de processus, un contrôleur XML-RPC et un tableau de bord web intégré pour surveiller et contrôler les processus. Il dispose d'un exportateur de métriques Prometheus qui sert des données de performance en temps réel via un point de terminaison HTTP dédié et sécurise ces interfaces distantes via une authentification de base. Le système couvre de larges domaines de capacités, incluant la gestion des logs avec rotation basée sur la taille, la vérification automatique de santé via polling TCP et HTTP, et l'orchestration du cycle de vie des services via une planification par priorité de groupe. Il fournit également des déclencheurs d'actions pilotés par événements, un nettoyeur de processus enfants pour éliminer les processus zombies, et une interface en ligne de commande pour le contrôle manuel des processus. Le logiciel inclut des utilitaires pour la génération de modèles de configuration et peut être intégré en tant que service système en utilisant des fichiers d'environnement personnalisés.

    Captures standard output and error streams from child processes into files with configurable rotation and size limits.

    Go
    Voir sur GitHub↗4,262
  • fabien-d/alertify.jsAvatar de fabien-d

    fabien-d/alertify.js

    4,225Voir sur GitHub↗

    alertify.js is a JavaScript notification library and modal dialog framework. It provides a system for creating customizable alert, confirm, and prompt dialogs to replace standard browser notifications, alongside a non-blocking alert system for unobtrusive status messages. The project features a sequential dialog queue that allows multiple alert and prompt windows to be chained together in a defined order. It also includes a JavaScript error logger that captures global runtime errors and displays them as visible notifications to assist with debugging. The library covers interactive dialog pri

    Redirects global window errors to visible notification boxes to simplify the runtime debugging process.

    JavaScript
    Voir sur GitHub↗4,225
  1. Home
  2. Web Development
  3. Error Handling
  4. Execution Error Captures

Explorer les sous-tags

  • Effect State InspectionSide-effecting operations that observe the state of a failure without modifying the outcome. **Distinct from Execution Error Captures:** Focuses on non-intrusive inspection (tapping) of the error channel, whereas the candidate focuses on capturing and routing errors.
  • Process-Level Error Logging2 sous-tagsCapturing stack traces and stdout/stderr from the process level to diagnose framework or infrastructure failures. **Distinct from Execution Error Captures:** Focuses on infrastructure-level process errors rather than concurrent task stream errors.
  • State Update Error CapturesInterception of errors specifically during the process of updating application state to prevent invalid transitions. **Distinct from Execution Error Captures:** Focuses on errors during the reducer/state update phase rather than general task execution or rendering errors.
  • Stream Error CleanupsExecuting side-effects such as logging or resource release when a stream fails, without altering the stream's output. **Distinct from Execution Error Captures:** Distinct from Execution Error Captures: focuses on running cleanup side-effects on stream failure rather than capturing errors from concurrent tasks.