google/gops
Gops
gops is a command-line diagnostic toolset for monitoring, profiling, and managing the runtime state of active Go applications. It functions as a runtime diagnostic tool that provides a focused interface for analyzing memory, profiling performance, and monitoring the health of running processes.
The tool provides a set of specialized utilities including a performance profiler for capturing CPU and heap profiles, a memory analyzer for identifying leaks and triggering garbage collection, and a process monitor for discovering running binaries and visualizing process hierarchies.
The project covers a broad range of diagnostic capabilities, including runtime execution tracing, stack trace capture, and resource usage sampling. It also includes system utilities for process metadata inspection, binary path resolution, and the monitoring of runtime metrics such as thread counts and memory statistics.
Features
- Go Process Diagnostics - Provides a comprehensive suite of utilities for inspecting the runtime state and resource usage of executing Go binaries.
- Per-Process Resource Metrics - Reports detailed per-process resource consumption including CPU, memory, thread counts, and network connections for Go processes.
- Heap and CPU Profilers - Captures CPU and heap profiles from live processes and integrates with interactive viewers to analyze bottlenecks.
- Runtime Profiling Hooks - Leverages internal runtime hooks to extract heap snapshots, CPU profiles, and execution traces from live applications.
- Remote Runtime Controllers - Sends control signals to running Go processes to trigger garbage collection and other diagnostic commands externally.
- Diagnostic Agents - Implements background agents within target processes to expose internal runtime state to external tools.
- Runtime Statistics Analysis - Reports current Go memory and runtime statistics, including active concurrent execution threads, to assess resource allocation.
- Process Hierarchy Traversals - Traverses the operating system process tree to map active Go binaries and their parent-child relationships.
- Go Process Monitors - Tracks resource usage and visualizes process hierarchies specifically for Go binaries to maintain operational health.
- Runtime Memory Management - Detects memory leaks and allows manual triggering of garbage collection cycles in active Go processes.
- Runtime Health Monitors - Provides tools to evaluate the operational health of running Go processes by collecting memory and CPU usage metrics.
- Go Runtime Analyzers - Provides a diagnostic interface for inspecting Go runtime memory statistics and managing garbage collection.
- System Usage Monitoring - Monitors Go process health and resource usage over defined durations to evaluate system impact.
- Application Performance Profiling - Captures CPU and heap profiles from live Go applications to identify and resolve performance bottlenecks.
- Application Stack Trace Capturers - Retrieves current stack traces from target Go programs to diagnose internal execution states and crashes.
- Go Runtime Profilers - Captures CPU profiles, heap snapshots, and execution traces specifically from the Go runtime.
- Execution Tracers - Triggers the Go runtime tracer to record event sequences and examine scheduling patterns and concurrency issues.
- Performance Profiling - Collects CPU and heap data using system signals to capture performance snapshots without interrupting the execution flow.
- Runtime Resource Usage Samplers - Samples CPU and memory consumption data over defined periods to calculate average resource usage levels.
- Signal-Triggered Profilers - Triggers profile captures and diagnostic actions in remote processes using specific operating system signals.
- Garbage Collection Tuning - Allows forcing immediate memory reclamation and adjusting GC thresholds to optimize running Go processes.
- Process Hierarchy Visualizations - Visualizes the parent-child relationships and execution dependencies of running Go processes in a tree view.
- Process Memory Access - Accesses the memory space of target Go processes to read runtime statistics and trigger GC.
- Go Binary Tracing - Records sequences of system events within live Go processes to debug complex concurrency issues.
- Unix Socket Metric Exposures - Exposes internal Go runtime metrics and control functions through a local Unix domain socket for external diagnostic access.
- Process List Displays - Lists active Go processes with identifiers, parent IDs, and version information in a sortable format.
- Process Metadata Inspection - Inspects detailed runtime metadata of active Go processes, including build versions and file paths, for auditing.
- Binary Path Resolution - Maps system process identifiers to their absolute binary paths to identify specific Go executable versions.
- Event Stream Recording - Records sequences of runtime system events over a specific duration to identify bottlenecks during complex operations.
- DevOps & Infrastructure - Tool for diagnosing and monitoring running processes.
- Debugging And Profiling - Tool for monitoring and debugging Go processes.
- Instrumentation and Tracing - Lists and diagnoses running Go processes.
