Observer CLI

https://github.com/zhongwencool/observer_cli
Admin
Observer CLI is a high-performance library designed to assist DevOps in diagnosing problems in...
Tokens:5,917
Snippets:24
Trust Score:9.1
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Observer CLI Start Plugin View

Source: https://github.com/zhongwencool/observer_cli/blob/main/docs/plugin.md

Demonstrates how to start the observer_cli application to display a specific plugin's view as the main interface, overriding the default HOME view.

```erlang
% your_cli.erl
start() -> observer_cli:start_plugin().
```

--------------------------------

### Start observer_cli in local Elixir shell

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Demonstrates how to start the observer_cli application within a local Elixir shell (iex) after setting up a mix project.

```elixir
%% mix project
iex -S mix
iex(1)> :observer_cli.start
```

--------------------------------

### Start observer_cli in local Erlang shell

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Demonstrates how to start the observer_cli application within a local Erlang shell after setting up a rebar3 project.

```erlang
%% rebar3 project
rebar3 shell
1> observer_cli:start().
```

--------------------------------

### Install observer_cli in Erlang Project

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Shows how to add the observer_cli library as a dependency in an Erlang project using rebar.config or erlang.mk.

```erlang
%% rebar.config
{deps, [observer_cli]}
%% erlang.mk
dep_observer_cli = hex 1.8.3
```

--------------------------------

### Observer CLI Plugin Configuration

Source: https://github.com/zhongwencool/observer_cli/blob/main/docs/plugin.md

Configures observer_cli to find and load custom plugins. It specifies the plugin's module, menu title, shortcut for switching, and optional refresh interval and sort column.

```erlang
%% module       - Specific module implements plugin behavior. It's mandatory.
%% title        - Menu title. It's mandatory.
%% shortcut     - Switch plugin by shortcut. It's mandatory.
%% interval     - Refresh interval ms. It's optional. default is 1500ms.
%% sort_column  - Sort the sheet by this index. It's optional default is 2.

{plugins,
  [
    #{module => observer_cli_plug_behaviour_x, title => "XPlug",
      interval => 1600, shortcut => "X", sort_column => 3},
    #{module => observer_cli_plug_behaviour_y, title => "YPlug",
      interval =>2000, shortcut => "Y", sort_column => 3}
  ]
}
```

--------------------------------

### Install observer_cli in Elixir Project

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Shows how to add the observer_cli library as a dependency in an Elixir project using mix.exs.

```elixir
# mix.exs
   def deps do
     [{:observer_cli, "~> 1.8"}]
   end
```

--------------------------------

### Observer CLI Plugin Attributes Callback

Source: https://github.com/zhongwencool/observer_cli/blob/main/docs/plugin.md

Implements the `attributes/1` callback for the observer_cli_plugin behavior. This callback returns rows of data for display, including content, width, and optional color formatting.

```erlang
-callback attributes(PrevState) -> {[Rows], NewState} when
    Rows :: #{content => string()|integer()|{byte, pos_integer()}, 
              width => pos_integer(), color => binary()}.

attributes(PrevState) ->
  Attrs = [
    [
      #{content => "XXX Ets Size", width => 15},
      #{content => 122, width => 10},
      #{content => "Memory Capcity", width => 15},
      #{content => {percent, 0.12}, width => 16},
      #{content => "XYZ1 Process Mem", width => 19},
      #{content => {byte, 1023 * 1203}, width => 19}
    ],
    [
      #{content => "YYY Ets Size", width => 15},
      #{content => 43, width => 10},
      #{content => "Disk Capcity", width => 15},
      #{content => {percent, 0.23}, width => 16},
      #{content => "XYZ2 Process Mem", width => 19},
      #{content => {byte, 2034 * 220}, width => 19}
    ],
    [
      #{content => "ZZZ Ets Size", width => 15},
      #{content => 108, width => 10},
      #{content => "Volume Capcity", width => 15},
      #{content => {percent, 0.101}, width => 16},
      #{content => "XYZ3 Process Mem", width => 19},
      #{content => {byte, 12823}, width => 19}
    ]
  ],
  NewState = PrevState,
  {Attrs, NewState}.
```

--------------------------------

### Observer CLI Plugin Sheet Body Callback

Source: https://github.com/zhongwencool/observer_cli/blob/main/docs/plugin.md

Implements the `sheet_body/1` callback for the observer_cli_plugin behavior. This function generates the data rows for the display sheet, processing process information and formatting it for output.

```erlang
-callback sheet_body(PrevState) -> {[SheetBody], NewState} when
    PrevState :: any(),
    SheetBody :: list(),
    NewState :: any().

sheet_body(PrevState) ->
  Body = [
    begin
      Register = 
        case erlang:process_info(Pid, registered_name) of
          [] -> [];
          {_, Name} -> Name
        end,
      [
        Pid,
        Register,
        {byte, element(2, erlang:process_info(Pid, memory))},
        element(2, erlang:process_info(Pid, reductions)),
        element(2, erlang:process_info(Pid, message_queue_len))
      ]
    end
    || Pid <- erlang:processes()
  ],
  NewState = PrevState,
  {Body, NewState}.
```

--------------------------------

### Observer CLI Plugin Sheet Header Callback

Source: https://github.com/zhongwencool/observer_cli/blob/main/docs/plugin.md

Implements the `sheet_header/0` callback for the observer_cli_plugin behavior. This function defines the column headers for the plugin's display sheet, including title, width, and optional shortcut.

```erlang
-callback sheet_header() -> [SheetHeader] when
    SheetHeader :: #{title => string(), width => pos_integer(), shortcut => string()}.

sheet_header() ->
  [
    #{title => "Pid", width => 15},
    #{title => "Register", width => 20},
    #{title => "Memory", width => 20, shortcut => "S"},
    #{title => "Reductions", width => 23, shortcut => "R"},
    #{title => "Message Queue Len", width => 23, shortcut => "Q"}
  ].
```

--------------------------------

### Get Erlang Process State

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Retrieves the state of an Erlang process using the sys module. This is a specific method for accessing process state, often used in conjunction with erlang:process_info.

```APIDOC
sys:get_state(Pid, MaxDepth)
  - Gets the state of a process.
  - Parameters:
    - Pid: The process identifier.
    - MaxDepth: The maximum depth for the state representation (e.g., 2500).
```

--------------------------------

### Erlang System Information and Configuration

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Provides details on retrieving Erlang system information and configuring VM limits. Includes functions for system stats and commands for setting process, port, and atom limits.

```APIDOC
erlang:system_info(Item)
  - Returns specified information about the current Erlang system.
  - Item can be 'process_count', 'port_count', 'atom_count', etc.
  - When a ratio (e.g., process_count/process_limit) exceeds 85%, it is displayed in red.

Erlang VM Configuration (via erl command line flags):
  +P Number
    - Sets the maximum number of simultaneously existing processes.
    - Valid range: [1024-134217727]. Default: 262144.
  +Q Number
    - Sets the maximum number of simultaneously existing ports.
    - Valid range: [1024-134217727]. Default: 65536 (or max file descriptors if larger).
  +t size
    - Sets the maximum number of atoms the virtual machine can handle.
    - Default: 1,048,576.
```

--------------------------------

### Generate observer_cli escript

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Instructions to generate an escript executable for the observer_cli project, allowing it to be run as a standalone command-line tool.

```bash
1. cd path/to/observer_cli/
2. `rebar3 escriptize` to generate an escript executable containing the project's and its dependencies' BEAM files.
   Place script(`_build/default/bin/observer_cli`) anywhere in your path and use `observer_cli` command.
3. `observer_cli TARGETNODE [TARGETCOOKIE REFRESHMS]` to monitor remote node.
```

--------------------------------

### Recon Process Information Functions

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Provides functions to list and analyze processes based on various metrics like memory, reductions, and message queue length. Supports absolute values or sliding time windows.

```APIDOC
recon:proc_count(Metric, N)
  - Lists the top N processes consuming a specific metric (e.g., memory).
  - Example: recon:proc_count(memory, 10) to find top 10 memory consumers.
  - Parameters:
    - Metric: The metric to sort by (e.g., memory, reductions, binary, total_heap_size, message_queue_len).
    - N: The number of top processes to return.
```

```APIDOC
recon:proc_window(Metric, WindowSize, Step)
  - Provides process information over a sliding time window.
  - Useful for observing trends in process behavior.
  - Parameters:
    - Metric: The metric to track (e.g., memory, reductions).
    - WindowSize: The duration of the sliding window.
    - Step: The interval at which to sample.
```

--------------------------------

### Process Statistics (ps command)

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Reports snapshots of Erlang (BEAM) processes using the 'ps' command. Useful for monitoring CPU and memory utilization of individual processes.

```shell
ps -o pcpu
  - Displays the CPU utilization of a process.
  - Format: "##.#" (percentage).
  - Calculation: CPU time used / process running time.

ps -o pmem
  - Displays the memory utilization of a process.
  - Format: percentage.
  - Calculation: process resident set size / physical memory on the machine.
```

--------------------------------

### Erlang Memory and Statistics

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Provides functions to inspect Erlang emulator's memory usage and various runtime statistics. Useful for performance tuning and debugging.

```APIDOC
erlang:memory()
  - Returns a list with information about dynamically allocated memory by the Erlang emulator.

erlang:statistics(Statistic)
  - Returns runtime statistics.
  - Supported Statistics:
    - active_task: Tasks expected to be CPU bound (excludes dirty IO).
    - context_switches: Total context switches since system start.
    - reductions(total/sinceLastCall): Total reductions or reductions since last call.
    - io: Bytes received/sent through ports and growth during refresh interval.
    - garbage_collection: Total GC value and {Number_of_GCs, Words_Reclaimed} growth.
    - run_queue: Total length of all normal run-queues (excludes dirty run queues).
```

--------------------------------

### Erlang System Information

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Retrieves various system-level information from the Erlang VM. This includes details about memory allocators, block sizes, and cache hit rates, which are crucial for performance tuning and understanding memory management.

```Erlang
%% Get general system information
erlang:system_info(allocator).

%% Get average block sizes for allocators
recon_alloc:average_block_sizes(current).
recon_alloc:average_block_sizes(max).

%% Get cache hit rates for allocators
recon_alloc:cache_hit_rates().
```

--------------------------------

### Erlang Process Information Details

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Retrieves detailed information about a specific Erlang process, including its state, links, status, resource usage, and call stack. This function is safe for production environments.

```APIDOC
erlang:process_info(Pid, Item)
  - Returns specific information about a process identified by Pid.
  - Common Items:
    - registered_name: The registered name of the process.
    - trap_exit: Boolean indicating if exit signals are trapped.
    - group_leader: The process group leader for IO.
    - initial_call: The initial function call when the process was spawned.
    - links: List of processes linked to this one.
    - monitored_by: List of processes monitoring this one.
    - monitors: List of monitors active for this process.
    - status: Current scheduler status (e.g., running, waiting, suspended).
    - reductions: Number of reductions performed by the process.
    - memory: Memory usage details (heap_size, total_heap_size, etc.).
    - messages: List of unprocessed messages in the queue.
    - dictionary: Contents of the process dictionary.
    - current_stack: Current call stack trace.
    - state: Process state obtained via sys:get_state/2.
```

```APIDOC
erlang:process_info(Pid)
  - Returns all available information for a process identified by Pid.
```

--------------------------------

### Erlang Scheduler Utilization Statistics

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Retrieves scheduler wall time statistics to understand total scheduler utilization. A value of 1.0 indicates all schedulers were active.

```APIDOC
erlang:statistics(scheduler_wall_time)
  - Returns the total scheduler utilization as a float.
  - Useful for identifying if schedulers are busy waiting for OS resources.
```

--------------------------------

### Erlang Mnesia Table Information

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Details how to query information from Mnesia tables, a distributed database system in Erlang. It focuses on retrieving table statistics, particularly memory usage, to monitor database performance and resource consumption.

```APIDOC
mnesia:table_info(Table, Item)
  - Retrieves information about a Mnesia table.
  - Parameters:
    - Table: The Mnesia table identifier.
    - Item: The specific information to retrieve (e.g., 'memory', 'size', 'name', 'type').
  - Returns: The requested information about the table.

  Example:
  mnesia:table_info(user_account, memory).
  mnesia:table_info(user_account, size).

  Note: Mnesia tables can be configured for different storage types (e.g., ram_copies, disc_copies) affecting memory usage and persistence.
```

--------------------------------

### Monitor remote node with Elixir

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Connects to and monitors a remote Elixir node using observer_cli, specifying the target node name and cookie.

```elixir
%% mix project
iex --name "observer_cli@127.0.0.1" -S mix
iex(1)> :observer_cli.start(:'target@host', :'magic_cookie')
```

--------------------------------

### Monitor remote node with Erlang

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Connects to and monitors a remote Erlang node using observer_cli, specifying the target node name and cookie.

```erlang
%% rebar3 project
rebar3 shell --name 'observer_cli@127.0.0.1'
1> observer_cli:start('target@host', 'magic_cookie').
```

--------------------------------

### Erlang ETS Table Information

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Provides methods to inspect Erlang Term Storage (ETS) tables. ETS tables are persistent in memory until explicitly deleted or cleared. This documentation covers how to retrieve information about table size and contents.

```APIDOC
ets:info(Table, Item)
  - Retrieves information about an ETS table.
  - Parameters:
    - Table: The ETS table identifier.
    - Item: The specific information to retrieve (e.g., 'memory', 'size', 'name').
  - Returns: The requested information about the table.

  Example:
  ets:info(my_table, memory).
  ets:info(my_table, size).

  Note: ETS tables are not garbage collected automatically and require manual record deletion or table deletion to reclaim memory.
```

--------------------------------

### Erlang Application Controller Info Function

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Provides a method to retrieve application debug information. This function is part of the Erlang OTP `application_controller` module and is used for debugging application states.

```erlang
application_controller:info()
```

--------------------------------

### Erlang Network Statistics

Source: https://github.com/zhongwencool/observer_cli/blob/main/README.md

Fetches network statistics from Erlang ports (TCP, UDP, SCTP). It uses functions from the 'recon' and 'inet' modules to retrieve byte counts, packet counts, and socket information. This helps in identifying bandwidth usage and port-specific details.

```Erlang
%% Fetch total input/output bytes
erlang:statistics(io).

%% Fetch statistics for all inet ports
recon:inet_count(Port, Attribute).
recon:inet_windows(Port, Attribute, Options).

%% Get specific attribute information
inet:getstat(Socket, Attribute).
inet:getopts(Socket, Option).
inet:sockname(Socket).
inet:peername(Socket).

%% Get detailed port information
recon:port_info(Port, InfoItem).
```
Tokens:
Raw