File 1041-observer-runtime_tools-Add-a-tab-for-socke... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 1041-observer-runtime_tools-Add-a-tab-for-sockets.patch of Package erlang (Revision 63ff62e87690e42782ca999e9a4b568d)

Currently displaying revision 63ff62e87690e42782ca999e9a4b568d , Show latest

From d5dcaa406e56e30772467621d9ca898b04741457 Mon Sep 17 00:00:00 2001
From: Micael Karlberg <bmk@erlang.org>
Date: Tue, 27 Apr 2021 18:28:38 +0200
Subject: [PATCH 01/17] [observer,runtime_tools] Add a tab for 'sockets'

A tab has been added for the 'new' socket(s).

OTP-17346
---
 lib/kernel/src/gen_tcp_socket.erl          |   2 +-
 lib/kernel/src/socket.erl                  |  29 +-
 lib/observer/src/Makefile                  |   5 +-
 lib/observer/src/observer.app.src          |   3 +-
 lib/observer/src/observer_lib.erl          |  27 +-
 lib/observer/src/observer_sock_wx.erl      | 821 ++++++++++++++++++
 lib/observer/src/observer_wx.erl           |  65 +-
 lib/observer/test/Makefile                 |  14 +-
 lib/observer/test/observer_socket_test.erl | 951 +++++++++++++++++++++
 lib/runtime_tools/src/observer_backend.erl | 102 ++-
 10 files changed, 1997 insertions(+), 22 deletions(-)
 create mode 100644 lib/observer/src/observer_sock_wx.erl
 create mode 100644 lib/observer/test/observer_socket_test.erl

diff --git a/lib/kernel/src/socket.erl b/lib/kernel/src/socket.erl
index ead4f8a151..a5c27339b8 100644
--- a/lib/kernel/src/socket.erl
+++ b/lib/kernel/src/socket.erl
@@ -72,6 +72,11 @@
          cancel/2
         ]).
 
+%% Misc utility functions
+-export([
+	 which_socket_kind/1
+	]).
+
 -export_type([
               socket/0,
               socket_handle/0,
@@ -864,7 +869,7 @@ monitored_by(Socket) ->
 
 -spec to_list(Socket) -> list() when
       Socket :: socket().
-
+    
 to_list(?socket(SockRef)) when is_reference(SockRef) ->
     "#Ref" ++ Id = erlang:ref_to_list(SockRef),
     "#Socket" ++ Id;
@@ -872,6 +877,28 @@ to_list(Socket) ->
     erlang:error(badarg, [Socket]).
 
 
+%% *** which_socket_kind/1 ***
+%%
+%% Utility function that returns the "kind" of socket.
+%% That is, if its a "plain" socket or a compatibillity socket.
+%%
+
+-spec which_socket_kind(Socket :: socket()) -> plain | compat.
+
+which_socket_kind(?socket(SockRef) = Socket) when is_reference(SockRef) ->
+    case prim_socket:getopt(SockRef, {otp,meta}) of
+	{ok, undefined} ->
+	    plain;
+	{ok, _} ->
+	    compat;
+	{error, _} ->
+	    erlang:error(badarg, [Socket])
+    end;
+which_socket_kind(Socket) ->
+    erlang:error(badarg, [Socket]).
+
+
+
 %% ===========================================================================
 %%
 %% Debug features
diff --git a/lib/observer/src/Makefile b/lib/observer/src/Makefile
index f9f239db37..4280557d45 100644
--- a/lib/observer/src/Makefile
+++ b/lib/observer/src/Makefile
@@ -1,7 +1,7 @@
 #
 # %CopyrightBegin%
 #
-# Copyright Ericsson AB 2002-2016. All Rights Reserved.
+# Copyright Ericsson AB 2002-2021. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -35,7 +35,7 @@ RELSYSDIR = $(RELEASE_PATH)/lib/observer-$(VSN)
 # Common Macros
 # ----------------------------------------------------
 
-MODULES= \
+MODULES = \
 	crashdump_viewer \
 	cdv_atom_cb \
 	cdv_bin_cb \
@@ -71,6 +71,7 @@ MODULES= \
 	observer_port_wx \
 	observer_pro_wx \
 	observer_procinfo \
+	observer_sock_wx \
 	observer_sys_wx \
 	observer_trace_wx \
 	observer_traceoptions_wx \
diff --git a/lib/observer/src/observer.app.src b/lib/observer/src/observer.app.src
index ca65ee703e..d642f61ecd 100644
--- a/lib/observer/src/observer.app.src
+++ b/lib/observer/src/observer.app.src
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 2002-2018. All Rights Reserved.
+%% Copyright Ericsson AB 2002-2021. All Rights Reserved.
 %% 
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -55,6 +55,7 @@
 	       observer_port_wx,
 	       observer_pro_wx,
 	       observer_procinfo,
+	       observer_sock_wx,
 	       observer_sys_wx,
 	       observer_trace_wx,
 	       observer_traceoptions_wx,
diff --git a/lib/observer/src/observer_lib.erl b/lib/observer/src/observer_lib.erl
index 7d115306bd..57a9a741a5 100644
--- a/lib/observer/src/observer_lib.erl
+++ b/lib/observer/src/observer_lib.erl
@@ -146,15 +146,26 @@ display_info(Frame, Info) ->
     {Panel, Sizer, InfoFs}.
 
 display_info(Panel, Sizer, Info) ->
+    d("display_info -> entry with"
+      "~n   Panel: ~p"
+      "~n   Sizer: ~p"
+      "~n   Info:  ~p", [Panel, Sizer, Info]),
     wxSizer:addSpacer(Sizer, 5),
     Add = fun(BoxInfo) ->
+		  d("display_info:add -> entry with"
+		    "~n   BoxInfo:  ~p", [BoxInfo]),
 		  case create_box(Panel, BoxInfo) of
 		      {Box, InfoFs} ->
+			  d("display_info:add -> box created"
+			    "~n   Box:    ~p"
+			    "~n   InfoFs: ~p", [Box, InfoFs]),
 			  wxSizer:add(Sizer, Box,
-				      [{flag, ?wxEXPAND bor ?wxALL}, {border, 5}]),
+				      [{flag, ?wxEXPAND bor ?wxALL},
+				       {border, 5}]),
 			  wxSizer:addSpacer(Sizer, 5),
 			  InfoFs;
 		      undefined ->
+			  d("display_info:add -> box *not* created"),
 			  []
 		  end
 	  end,
@@ -889,3 +900,17 @@ make_obsbin(Bin,Tab) ->
     Key = {Preview, Size, Hash},
     ets:insert(Tab, {Key,Bin}),
     ['#OBSBin',Preview,PreviewBitSize,Size,Hash].
+
+
+d(F) ->
+    d(F, []).
+
+d(F, A) ->
+    d(get(debug), F, A).
+
+d(true, F, A) ->
+    io:format("[ol] " ++ F ++ "~n", A);
+d(_, _, _) ->
+    ok.
+
+
diff --git a/lib/observer/src/observer_sock_wx.erl b/lib/observer/src/observer_sock_wx.erl
new file mode 100644
index 0000000000..dc91d0f050
--- /dev/null
+++ b/lib/observer/src/observer_sock_wx.erl
@@ -0,0 +1,821 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2021-2021. All Rights Reserved.
+%%
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%
+%% %CopyrightEnd%
+-module(observer_sock_wx).
+
+%% {ok, S1} = socket:open(inet, stream, tcp).
+%% {ok, S2} = socket:open(inet6, stream, tcp).
+%% {ok, S3} = gen_tcp:listen(0, [{inet_backend, socket}]).
+%% {ok, S4} = socket:open(local, stream, default).
+%% ok = socket:bind(S4, #{family => local, path => "/tmp/foobar"}).
+
+-export([start_link/3]).
+
+%% wx_object callbacks
+-export([init/1, handle_info/2, terminate/2, code_change/3, handle_call/3,
+	 handle_event/2, handle_sync_event/3, handle_cast/2]).
+
+-behaviour(wx_object).
+-include_lib("wx/include/wx.hrl").
+-include("observer_defs.hrl").
+
+-define(GRID, 300).
+-define(ID_REFRESH, 301).
+-define(ID_REFRESH_INTERVAL, 302).
+-define(ID_SOCKET_INFO, 303).
+-define(ID_SOCKET_INFO_SELECTED, 304).
+%% -define(ID_DEBUG_SOCKETS, 305).
+%% -define(ID_DEBUG_NAMES, 306).
+-define(ID_DEBUG_NEW, 307).
+%% -define(ID_DEBUG_ALL, 308).
+-define(ID_CLOSE_SOCKET, 309).
+
+-define(DEBUG_SOCKETS_STR, "Debug selected sockets").
+
+-record(socket,
+	{id,
+	 id_str,
+	 kind,
+	 fd,
+	 owner,
+	 domain,
+	 type,
+	 protocol,
+	 raddress,
+	 laddress,
+	 rstate,
+         wstate,
+	 monitored_by,
+	 statistics}).
+
+-record(opt, {sort_key  = 2,
+	      sort_incr = true,
+              odd_bg
+	     }).
+
+-record(state,
+	{
+	  parent,
+	  grid,
+	  panel,
+	  sizer,
+	  fields,
+	  node = {node(),true},
+	  opt  = #opt{},
+	  right_clicked_socket,
+	  sockets,
+	  timer,
+	  open_wins=[]
+	}).
+
+start_link(Notebook,  Parent, Config) ->
+    wx_object:start_link(?MODULE, [Notebook, Parent, Config], []).
+
+info_fields() ->
+    Gen = [{"General socket info",
+	    [{"IOV Max",                                 iov_max},
+	     {"Counter Size (in bits)",                  num_cnt_bits},
+	     {"Number of sockets",                       num_sockets},
+	     {"Number of (socket) monitors",             num_monitors},
+	     {"Number of sockets in the 'inet' domain",  num_dinet},
+	     {"Number of sockets in the 'inet6' domain", num_dinet6},
+	     {"Number of sockets in the 'local' domain", num_dlocal},
+	     {"Number of type 'stream' sockets",         num_tstreams},
+	     {"Number of type 'dgram' sockets",          num_tdgrams},
+	     {"Number of type 'seqpacket' sockets",      num_tseqpkgs},
+	     {"Number of protocol 'ip' sockets",         num_pip},
+	     {"Number of protocol 'sctp' sockets",       num_psctp},
+	     {"Number of protocol 'tcp' sockets",        num_ptcp},
+	     {"Number of protocol 'udp' sockets",        num_pudp}
+	    ]}],
+    Gen.
+
+update_gen_socket_info(#state{node   = {Node, true},
+			      fields = Fields,
+			      sizer  = Sizer}) ->
+    case rpc:call(Node, observer_backend, socket_info, []) of
+	Info when is_list(Info) ->
+	    Gen = info_fields(),
+	    observer_lib:update_info(Fields, observer_lib:fill_info(Gen, Info)),
+	    wxSizer:layout(Sizer);
+	_ ->
+	    ignore
+    end;
+update_gen_socket_info(#state{node = _}) ->
+    ignore.
+
+
+%% Two parts of this panel:
+%% 1) First part is general socket info (basically: socket:info/0)
+%% 2) Second part is a list (grid) och each socket and info about it
+init([Notebook, Parent, Config]) ->
+    %% put(debug, true),
+    d("init -> entry with"
+      "~n      Notebook: ~p"
+      "~n      Parent:   ~p"
+      "~n      Config:   ~p", [Notebook, Parent, Config]),
+    Info   = observer_backend:socket_info(),
+    Gen    = info_fields(),
+    Panel  = wxPanel:new(Notebook),
+    Sizer  = wxBoxSizer:new(?wxVERTICAL),
+    GenSizer = wxBoxSizer:new(?wxHORIZONTAL),
+    {GenPanel, _GenSizer, GenFields} =
+	observer_lib:display_info(Panel, observer_lib:fill_info(Gen, Info)),
+    wxSizer:add(GenSizer, GenPanel, [{flag, ?wxEXPAND}, {proportion, 1}]),
+    BorderFlags = ?wxLEFT bor ?wxRIGHT,
+    wxSizer:add(Sizer, GenSizer, [{flag, ?wxEXPAND bor BorderFlags bor ?wxTOP},
+				  {proportion, 0}, {border, 5}]),
+    Style  = ?wxLC_REPORT bor ?wxLC_HRULES,
+    Grid   = wxListCtrl:new(Panel, [{winid, ?GRID}, {style, Style}]),
+    wxSizer:add(Sizer, Grid, [{flag, ?wxEXPAND bor ?wxALL},
+			      {proportion, 1}, {border, 5}]),
+    wxWindow:setSizer(Panel, Sizer),
+    Li = wxListItem:new(),
+    AddListEntry = fun({Name, Align, DefSize}, Col) ->
+			   wxListItem:setText(Li, Name),
+			   wxListItem:setAlign(Li, Align),
+			   wxListCtrl:insertColumn(Grid, Col, Li),
+			   wxListCtrl:setColumnWidth(Grid, Col, DefSize),
+			   Col + 1
+		   end,
+    Scale = observer_wx:get_scale(),
+    ListItems = [{"Id",          ?wxLIST_FORMAT_LEFT, Scale*350},
+		 {"Owner",       ?wxLIST_FORMAT_LEFT, Scale*100},
+		 {"Fd",          ?wxLIST_FORMAT_LEFT, Scale*50},
+		 {"Domain",      ?wxLIST_FORMAT_LEFT, Scale*60},
+		 {"Type",        ?wxLIST_FORMAT_LEFT, Scale*100},
+		 {"Protocol",    ?wxLIST_FORMAT_LEFT, Scale*100},
+		 {"Read State",  ?wxLIST_FORMAT_LEFT, Scale*150},
+		 {"Write State", ?wxLIST_FORMAT_LEFT, Scale*150}],
+    lists:foldl(AddListEntry, 0, ListItems),
+    wxListItem:destroy(Li),
+
+    wxListCtrl:connect(Grid, command_list_item_right_click),
+    wxListCtrl:connect(Grid, command_list_item_activated),
+    wxListCtrl:connect(Grid, command_list_col_click),
+    wxListCtrl:connect(Grid, size, [{skip, true}]),
+
+    wxWindow:setFocus(Grid),
+    Even = wxSystemSettings:getColour(?wxSYS_COLOUR_LISTBOX),
+    Odd  = observer_lib:mix(Even,
+			    wxSystemSettings:getColour(?wxSYS_COLOUR_HIGHLIGHT),
+			    0.8),
+    Opt  = #opt{odd_bg = Odd},
+    {Panel, #state{parent = Parent,
+		   panel  = Panel,
+		   sizer  = Sizer,
+		   fields = GenFields,
+		   grid   = Grid,
+		   timer  = Config,
+		   opt    = Opt}}.
+
+handle_event(#wx{id=?ID_REFRESH},
+	     State = #state{node = Node,
+			    grid = Grid,
+			    opt  = Opt} = State) ->
+    d("handle_event(wx refresh) -> entry"),
+    _ = update_gen_socket_info(State),
+    Sockets0 = get_sockets(Node),
+    Sockets  = update_grid(Grid, sel(State), Opt, Sockets0),
+    {noreply, State#state{sockets = Sockets}};
+
+handle_event(#wx{obj=Obj, event=#wxClose{}}, #state{open_wins=Opened} = State) ->
+    d("handle_event(wx close) -> entry"),
+    NewOpened =
+	case lists:keytake(Obj,2,Opened) of
+	    false -> Opened;
+	    {value,_,Rest} -> Rest
+	end,
+    {noreply, State#state{open_wins=NewOpened}};
+
+handle_event(#wx{event=#wxList{type=command_list_col_click, col=Col}},
+	     State = #state{node=Node, grid=Grid,
+			    opt=Opt0=#opt{sort_key=Key, sort_incr=Bool}}) ->
+    d("handle_event(wx list cmd-list-col-click) -> entry"),
+    Opt = case Col+2 of
+	      Key -> Opt0#opt{sort_incr=not Bool};
+	      NewKey -> Opt0#opt{sort_key=NewKey}
+	  end,
+    Sockets0 = get_sockets(Node),
+    Sockets  = update_grid(Grid, sel(State), Opt, Sockets0),
+    wxWindow:setFocus(Grid),
+    {noreply, State#state{opt = Opt, sockets = Sockets}};
+
+handle_event(#wx{event=#wxSize{size={W,_}}},  State=#state{grid=Grid}) ->
+    d("handle_event(wx size) -> entry"),
+    observer_lib:set_listctrl_col_size(Grid, W),
+    {noreply, State};
+
+handle_event(#wx{event = #wxList{type      = command_list_item_activated,
+				 itemIndex = Index}},
+	     State = #state{grid      = Grid,
+			    sockets   = Sockets,
+			    open_wins = Opened}) ->
+    d("handle_event(wx list cmd-list-item-activated) -> entry"),
+    Socket    = lists:nth(Index+1, Sockets),
+    NewOpened = display_socket_info(Grid, Socket, Opened),
+    {noreply, State#state{open_wins = NewOpened}};
+
+handle_event(#wx{event = #wxList{type      = command_list_item_right_click,
+				 itemIndex = Index}},
+	     State = #state{panel = Panel, sockets=Sockets}) ->
+    d("handle_event(wx list cmd-list-item-right-clock) -> entry"),
+    case Index of
+	-1 ->
+	    {noreply, State};
+	_ ->
+	    Socket = lists:nth(Index + 1, Sockets),
+	    Menu   = wxMenu:new(),
+	    wxMenu:append(Menu, ?ID_SOCKET_INFO,
+			  f("Socket info for ~s", [Socket#socket.id_str])),
+	    %% wxMenu:append(Menu, ?ID_DEBUG_SOCKETS,
+	    %% 		  "Debug selected sockets",
+	    %% 		  [{help, ?DEBUG_SOCKETS_STR}]),
+	    wxMenu:append(Menu, ?ID_CLOSE_SOCKET,
+			  f("Close ~p", [Socket#socket.id_str])),
+	    wxWindow:popupMenu(Panel, Menu),
+	    wxMenu:destroy(Menu),
+	    {noreply, State#state{right_clicked_socket = Socket}}
+    end;
+
+handle_event(#wx{id = ?ID_SOCKET_INFO},
+	     State = #state{grid                 = Grid,
+			    right_clicked_socket = Socket,
+			    open_wins            = Opened}) ->
+    d("handle_event(wx socket info) -> entry"),
+    case Socket of
+	undefined ->
+	    {noreply, State};
+	_ ->
+	    NewOpened = display_socket_info(Grid, Socket, Opened),
+	    {noreply, State#state{right_clicked_socket = undefined,
+				  open_wins            = NewOpened}}
+    end;
+
+handle_event(#wx{id = ?ID_SOCKET_INFO_SELECTED},
+	     State = #state{grid      = Grid,
+			    sockets   = Sockets,
+			    open_wins = Opened}) ->
+    d("handle_event(wx socket info selected) -> entry"),
+    case get_selected_items(Grid, Sockets) of
+	[] ->
+	    observer_wx:create_txt_dialog(State#state.panel,
+					  "No selected sockets",
+					  "Socket Info", ?wxICON_EXCLAMATION),
+	    {noreply, State};
+	Selected ->
+	    NewOpened = lists:foldl(fun(S, O) ->
+					    display_socket_info(Grid, S, O)
+				    end,
+				    Opened, Selected),
+	    {noreply, State#state{open_wins = NewOpened}}
+    end;
+
+handle_event(#wx{id = ?ID_CLOSE_SOCKET},
+	     State = #state{right_clicked_socket = Socket}) ->
+    d("handle_event(wx close socket) -> entry"),
+    case Socket of
+	undefined ->
+	    {noreply, State};
+	_ ->
+	    socket:close(Socket#socket.id),
+	    {noreply, State#state{right_clicked_socket = undefined}}
+	end;
+
+%% handle_event(#wx{id=?ID_TRACE_PORTS}, #state{grid=Grid, ports=Ports}=State)  ->
+%%     case get_selected_items(Grid, Ports) of
+%% 	[] ->
+%% 	    observer_wx:create_txt_dialog(State#state.panel, "No selected ports",
+%% 					  "Tracer", ?wxICON_EXCLAMATION);
+%% 	Selected ->
+%% 	    SelectedIds = [Port#port.id || Port <- Selected],
+%% 	    observer_trace_wx:add_ports(SelectedIds)
+%%     end,
+%%     {noreply,  State};
+
+%% handle_event(#wx{id=?ID_TRACE_NAMES}, #state{grid=Grid, ports=Ports}=State)  ->
+%%     case get_selected_items(Grid, Ports) of
+%% 	[] ->
+%% 	    observer_wx:create_txt_dialog(State#state.panel, "No selected ports",
+%% 					  "Tracer", ?wxICON_EXCLAMATION);
+%% 	Selected ->
+%% 	    IdsOrRegs =
+%% 		[case Port#port.name of
+%% 		     [] -> Port#port.id;
+%% 		     Name -> Name
+%% 		 end || Port <- Selected],
+%% 	    observer_trace_wx:add_ports(IdsOrRegs)
+%%     end,
+%%     {noreply,  State};
+
+handle_event(#wx{id=?ID_DEBUG_NEW, event=#wxCommand{type=command_menu_selected}}, State) ->
+    d("handle_event(wx debug new, cmd-menu-selected) -> entry"),
+    observer_trace_wx:add_aockets([new_sockets]),
+    {noreply,  State};
+
+handle_event(#wx{id=?ID_REFRESH_INTERVAL},
+	     State = #state{grid=Grid, timer=Timer0}) ->
+    d("handle_event(wx refresh interval) -> entry"),
+    Timer = observer_lib:interval_dialog(Grid, Timer0, 10, 5*60),
+    {noreply, State#state{timer=Timer}};
+
+handle_event(#wx{obj=MoreEntry,event=#wxMouse{type=left_down},userData={more,More}}, State) ->
+    d("handle_event(wx mouse left-down, more) -> entry"),
+    observer_lib:add_scroll_entries(MoreEntry,More),
+    {noreply, State};
+
+handle_event(#wx{event=#wxMouse{type=left_down}, userData=TargetPid}, State) ->
+    d("handle_event(wx mouse left-down) -> entry"),
+    observer ! {open_link, TargetPid},
+    {noreply, State};
+
+handle_event(#wx{obj=Obj, event=#wxMouse{type=enter_window}}, State) ->
+    d("handle_event(wx mouse enter-win) -> entry"),
+    wxTextCtrl:setForegroundColour(Obj,{0,0,100,255}),
+    {noreply, State};
+
+handle_event(#wx{obj=Obj, event=#wxMouse{type=leave_window}}, State) ->
+    d("handle_event(wx mouse leave-win) -> entry"),
+    wxTextCtrl:setForegroundColour(Obj,?wxBLUE),
+    {noreply, State};
+
+handle_event(Event, _State) ->
+    d("handle_event(unknown event) -> entry with"
+      "~n   Event: ~p", [Event]),
+    error({unhandled_event, Event}).
+
+handle_sync_event(_Event, _Obj, _State) ->
+    ok.
+
+handle_call(get_config, _, #state{timer=Timer}=State) ->
+    {reply, observer_lib:timer_config(Timer), State};
+
+handle_call(Event, From, _State) ->
+    error({unhandled_call, Event, From}).
+
+handle_cast(Event, _State) ->
+    error({unhandled_cast, Event}).
+
+%% handle_info({socketinfo_open, IdStr},
+%% 	    State = #state{node      = {ActiveNodeName, ActiveAvailable},
+%% 			   grid      = Grid,
+%%                            opt       = Opt,
+%% 			   open_wins = Opened}) ->
+%%     NodeName = node(list_to_port(PortIdStr)), % How do we do this for sockets?
+%%     Available =
+%%         case NodeName of
+%%             ActiveNodeName ->
+%%                 ActiveAvailable;
+%%             _ ->
+%%                 portinfo_available(NodeName)
+%%         end,
+%%     if Available ->
+%%             Sockets0 = get_sockets(NodeName, Available),
+%%             Sockets  = lists:keyfind(SockIdStr, #socket.id_str, Sockets),
+%%             NewOpened =
+%%                 case Port of
+%%                     false ->
+%%                         self() ! {error,"No such socket: " ++ SockIdStr},
+%%                         Opened;
+%%                     _ ->
+%%                         display_socket_info(Grid, Port, Opened)
+%%                 end,
+%%             Ports =
+%%                 case NodeName of
+%%                     ActiveNodeName ->
+%%                         update_grid(Grid, sel(State), Opt, Ports0);
+%%                     _ ->
+%%                         State#state.ports
+%%                 end,
+%%             {noreply, State#state{ports=Ports, open_wins=NewOpened}};
+%%        true ->
+%%             popup_unavailable_info(NodeName),
+%%             {noreply, State}
+%%     end;
+
+handle_info(refresh_interval, State = #state{node    = Node,
+					     grid    = Grid,
+					     opt     = Opt,
+                                             sockets = OldSockets} = State) ->
+    d("handle_info(refresh_interval) -> entry"),
+    case get_sockets(Node) of
+        OldSockets ->
+            %% no change
+            {noreply, State};
+        Sockets0 ->
+	    d("handle_info(refresh_interval) -> ~w sockets",
+	      [length(Sockets0)]),
+	    _ = update_gen_socket_info(State),
+            Sockets = update_grid(Grid, sel(State), Opt, Sockets0),
+            {noreply, State#state{sockets = Sockets}}
+    end;
+
+handle_info({active, NodeName}, 
+	    #state{parent = Parent,
+		   grid   = Grid,
+		   opt    = Opt,
+		   timer  = Timer0} = State0) ->
+    Available = portinfo_available(NodeName),
+    Available orelse popup_unavailable_info(NodeName),
+    State1   = State0#state{node = {NodeName, Available}},
+    _ = update_gen_socket_info(State1),
+    Sockets0 = get_sockets(NodeName, Available),
+    Sockets  = update_grid(Grid, sel(State1), Opt, Sockets0),
+    wxWindow:setFocus(Grid),
+    create_menus(Parent),
+    Timer = observer_lib:start_timer(Timer0, 10),
+    {noreply, State1#state{sockets = Sockets,
+			   timer   = Timer}};
+
+handle_info(not_active, State = #state{timer = Timer0}) ->
+    Timer = observer_lib:stop_timer(Timer0),
+    {noreply, State#state{timer=Timer}};
+
+handle_info({info, {port_info_not_available,NodeName}},
+            State = #state{panel=Panel}) ->
+    Str = io_lib:format("Can not fetch port info from ~p.~n"
+                        "Too old OTP version.",[NodeName]),
+    observer_lib:display_info_dialog(Panel, Str),
+    {noreply, State};
+
+handle_info({error, Error}, #state{panel=Panel} = State) ->
+    Str = io_lib:format("ERROR: ~ts~n",[Error]),
+    observer_lib:display_info_dialog(Panel, Str),
+    {noreply, State};
+
+handle_info(_Event, State) ->
+    {noreply, State}.
+
+terminate(_Event, _State) ->
+    ok.
+
+code_change(_, _, State) ->
+    State.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+create_menus(Parent) ->
+    MenuEntries =
+	[{"View",
+	  [#create_menu{id = ?ID_SOCKET_INFO_SELECTED,
+			text = "Socket info for selected sockets\tCtrl-I"},
+	   separator,
+	   #create_menu{id = ?ID_REFRESH, text = "Refresh\tCtrl-R"},
+	   #create_menu{id = ?ID_REFRESH_INTERVAL, text = "Refresh Interval..."}
+	  ]}%% ,
+	 %% {"Debug",
+	 %%  [#create_menu{id=?ID_DEBUG_SOCKETS, text="Debug selected socket"},
+	 %%   #create_menu{id=?ID_DEBUG_NEW,     text="Debug new sockets"}
+	 %%  ]}
+	],
+    observer_wx:create_menus(Parent, MenuEntries).
+
+
+get_sockets({NodeName, Available}) ->
+    get_sockets(NodeName, Available);
+get_sockets(NodeName) when is_atom(NodeName) ->
+    case rpc:call(NodeName, observer_backend, get_socket_list, []) of
+	SocketInfoMaps when is_list(SocketInfoMaps) ->
+	    [infomap_to_rec(SockInfo) || SockInfo <- SocketInfoMaps];
+	{badrpc, Error} ->
+	    {error, Error};
+	{error, _} = ERROR ->
+	    ERROR
+    end.
+
+get_sockets(_NodeName, false) ->
+    [];
+get_sockets(NodeName, true) ->
+    case get_sockets(NodeName) of
+	{error, _} = ERROR ->
+	    self() ! ERROR,
+	    [];
+	Res ->
+	    Res
+    end.
+
+
+infomap_to_rec(#{id           := Id,
+		 id_str       := IdStr,
+		 kind         := Kind,
+		 fd           := FD,
+		 owner        := Owner,
+		 domain       := Domain,
+		 type         := Type,
+		 protocol     := Protocol,
+		 rstates      := RState,
+		 wstates      := WState,
+		 monitored_by := MonitoredBy,
+		 statistics   := Statistics} = Info) ->
+    d("infomap_to_rec -> entry with"
+      "~n   Id:          ~p"
+      "~n   IsStr:       ~p"
+      "~n   Kind:        ~p"
+      "~n   FD:          ~p"
+      "~n   Owner:       ~p"
+      "~n   Domain:      ~p"
+      "~n   Type:        ~p"
+      "~n   Protocol:    ~p"
+      "~n   RState:      ~p"
+      "~n   WState:      ~p"
+      "~n   MonitoredBy: ~p"
+      "~n   Statistics:  ~p",
+      [Id, IdStr, Kind, FD, Owner, Domain, Type, Protocol, RState, WState,
+       MonitoredBy, Statistics]),
+      #socket{id           = Id,
+	    id_str       = IdStr,
+	    kind         = Kind,
+	    fd           = FD,
+	    owner        = Owner,
+	    domain       = Domain,
+	    type         = Type,
+	    protocol     = Protocol,
+	    raddress     = maps:get(raddress, Info, undefined),
+	    laddress     = maps:get(laddress, Info, undefined),
+	    rstate       = RState,
+	    wstate       = WState,
+	    monitored_by = MonitoredBy,
+	    statistics   = Statistics}.
+
+socketrec_to_list(#socket{id           = Id,
+			  id_str       = IdStr,
+			  kind         = Kind,
+			  fd           = FD,
+			  owner        = Owner,
+			  domain       = Domain,
+			  type         = Type,
+			  protocol     = Protocol,
+			  raddress     = RAddr,
+			  laddress     = LAddr,
+			  rstate       = RState,
+			  wstate       = WState,
+			  monitored_by = MonitoredBy,
+			  statistics   = Statistics}) ->
+    d("socketrec_to_list -> entry with"
+      "~n   Id:          ~p"
+      "~n   IsStr:       ~p"
+      "~n   Kind:        ~p"
+      "~n   FD:          ~p"
+      "~n   Owner:       ~p"
+      "~n   Domain:      ~p"
+      "~n   Type:        ~p"
+      "~n   Protocol:    ~p"
+      "~n   RAddr:       ~p"
+      "~n   LAddr:       ~p"
+      "~n   RState:      ~p"
+      "~n   WState:      ~p"
+      "~n   MonitoredBy: ~p"
+      "~n   Statistics:  ~p",
+      [Id, IdStr, Kind, FD, Owner, Domain, Type, Protocol,
+       RAddr, LAddr, RState, WState,
+       MonitoredBy, Statistics]),
+    [{id,           Id},
+     {id_str,       IdStr},
+     {kind,         Kind},
+     {fd,           FD},
+     {owner,        Owner},
+     {domain,       Domain},
+     {type,         Type},
+     {protocol,     Protocol},
+     {raddress,     RAddr},
+     {laddress,     LAddr},
+     {rstate,       RState},
+     {wstate,       WState},
+     {monitored_by, MonitoredBy},
+     {statistics,   Statistics}].
+
+display_socket_info(Parent, #socket{id_str = IdStr} = Sock, Opened) ->
+    d("display_socket_info -> entry with"
+      "~n   IdStr: ~p", [IdStr]),
+    case lists:keyfind(IdStr, 1, Opened) of
+	false ->
+	    Frame = do_display_socket_info(Parent, Sock),
+	    [{IdStr, Frame}|Opened];
+	{_,Win} ->
+	    wxFrame:raise(Win),
+	    Opened
+    end.
+
+do_display_socket_info(Parent0, #socket{id_str = IdStr} = SocketRec) ->
+    d("do_display_socket_info -> entry with"
+      "~n   IdStr: ~p", [IdStr]),
+    Parent = observer_lib:get_wx_parent(Parent0),
+    Title = "Socket Info: " ++ IdStr,
+    Scale = observer_wx:get_scale(),
+    Frame = wxMiniFrame:new(Parent, ?wxID_ANY, Title,
+			    [{style, ?wxSYSTEM_MENU bor ?wxCAPTION
+				  bor ?wxCLOSE_BOX bor ?wxRESIZE_BORDER},
+                             {size,{Scale * 600, Scale * 400}}]),
+    ScrolledWin = wxScrolledWindow:new(Frame,[{style,?wxHSCROLL bor ?wxVSCROLL}]),
+    wxScrolledWindow:enableScrolling(ScrolledWin,true,true),
+    wxScrolledWindow:setScrollbars(ScrolledWin,20,20,0,0),
+    Sizer = wxBoxSizer:new(?wxVERTICAL),
+    wxWindow:setSizer(ScrolledWin,Sizer),
+    Socket = socketrec_to_list(SocketRec),
+    Fields0 = socket_info_fields(Socket),
+    _UpFields = observer_lib:display_info(ScrolledWin, Sizer, Fields0),
+    wxFrame:center(Frame),
+    wxFrame:connect(Frame, close_window, [{skip, true}]),
+    wxFrame:show(Frame),
+    Frame.
+
+
+
+socket_info_fields(Socket0) ->
+    {Struct0, Socket} = extra_fields(Socket0),
+    Struct =
+	[{"Overview",
+	  [{"Owner",            {click,owner}},
+	   {"Fd",               fd},
+	   {"Domain",           domain},
+           {"Type",             type},
+           {"Protocol",         protocol},
+           {"Read State",       rstate},
+           {"Write State",      wstate}]},
+	 {scroll_boxes,
+	  [{"Monitored by",1,{click,monitored_by}}]} | Struct0],
+    observer_lib:fill_info(Struct, Socket).
+
+extra_fields(Socket) ->
+    Statistics = proplists:get_value(statistics, Socket, []),
+    %% Struct = [{"Net",
+    %% 	       [{"Local Address",      local_address},
+    %% 		{"Local Port Number",  local_port},
+    %% 		{"Remote Address",     remote_address},
+    %% 		{"Remote Port Number", remote_port}]},
+    %% 	      {"Statistics",
+    %% 	       [stat_name_and_unit(Key) || {Key,_} <- Statistics]}],
+    Struct = [{"Net",
+	       [{"Local Address",  laddress},
+		{"Remote Address", raddress}]},
+	      {"Statistics",
+	       [stat_name_and_unit(Key) || {Key,_} <- Statistics]}],
+    Socket1 = lists:keydelete(statistics, 1, Socket),
+    {Struct, Socket1 ++ Statistics}.
+
+stat_name_and_unit(acc_fails = Key) ->
+    {"Number of accept fails", Key};
+stat_name_and_unit(acc_success = Key) ->
+    {"Number of accept success", Key};
+stat_name_and_unit(acc_tries = Key) ->
+    {"Number of accept tries", Key};
+stat_name_and_unit(acc_waits = Key) ->
+    {"Number of accept waits", Key};
+
+stat_name_and_unit(read_byte = Key) ->
+    {"Total read", {bytes, Key}};
+stat_name_and_unit(read_fails = Key) ->
+    {"Number of read fails", Key};
+stat_name_and_unit(read_tries = Key) ->
+    {"Number of read tries", Key};
+stat_name_and_unit(read_waits = Key) ->
+    {"Number of read waits", Key};
+stat_name_and_unit(read_pkg = Key) ->
+    {"Number of packats read", Key};
+stat_name_and_unit(read_pkg_max = Key) ->
+    {"Largest package read", {bytes, Key}};
+
+stat_name_and_unit(write_byte = Key) ->
+    {"Total written", {bytes, Key}};
+stat_name_and_unit(write_fails = Key) ->
+    {"Number of write fails", Key};
+stat_name_and_unit(write_tries = Key) ->
+    {"Number of write tries", Key};
+stat_name_and_unit(write_waits = Key) ->
+    {"Number of write waits", Key};
+stat_name_and_unit(write_pkg = Key) ->
+    {"Number of packats written", Key};
+stat_name_and_unit(write_pkg_max = Key) ->
+    {"Largest package written", {bytes, Key}};
+stat_name_and_unit(Key) ->
+    {atom_to_list(Key), Key}.
+
+%% filter_monitor_info() ->
+%%     fun(Data) ->
+%% 	    Ms = proplists:get_value(monitors, Data),
+%% 	    [Pid || {process, Pid} <- Ms]
+%%     end.
+
+update_grid(Grid, Sel, Opt, Ports) ->
+    wx:batch(fun() -> update_grid2(Grid, Sel, Opt, Ports) end).
+update_grid2(Grid, Sel, #opt{sort_key  = Sort,
+			     sort_incr = Dir,
+			     odd_bg    = BG}, Ports) ->
+    wxListCtrl:deleteAllItems(Grid),
+    Update =
+	fun(#socket{id       = Id,
+		    id_str   = IdStr,
+		    owner    = Owner,
+		    fd       = Fd,
+		    domain   = Domain,
+		    type     = Type,
+		    protocol = Proto,
+		    rstate   = RState,
+		    wstate   = WState},
+	    Row) ->
+		_Item = wxListCtrl:insertItem(Grid, Row, ""),
+		if (Row rem 2) =:= 1 ->
+			wxListCtrl:setItemBackgroundColour(Grid, Row, BG);
+		   true -> ignore
+		end,
+
+		lists:foreach(fun({Col, Val}) ->
+				      wxListCtrl:setItem(Grid, Row, Col,
+							 observer_lib:to_str(Val))
+			      end,
+			      [{0,IdStr},
+			       {1,Owner},
+			       {2,Fd},
+			       {3,Domain},
+			       {4,Type},
+			       {5,Proto},
+			       {6,if (RState =:= []) -> "-"; true -> RState end},
+			       {7,if (WState =:= []) -> "-"; true -> WState end}]),
+                case lists:member(Id, Sel) of
+                    true ->
+                        wxListCtrl:setItemState(Grid,
+						Row,
+						16#FFFF,
+						?wxLIST_STATE_SELECTED);
+                    false ->
+                        wxListCtrl:setItemState(Grid,
+						Row,
+						0,
+						?wxLIST_STATE_SELECTED)
+                end,
+		Row + 1
+	end,
+    PortInfo = case Dir of
+		   false -> lists:reverse(lists:keysort(Sort, Ports));
+		   true -> lists:keysort(Sort, Ports)
+	       end,
+    lists:foldl(Update, 0, PortInfo),
+    PortInfo.
+
+sel(#state{grid = Grid, sockets = Sockets}) ->
+    [Id || #socket{id = Id} <- get_selected_items(Grid, Sockets)].
+
+get_selected_items(Grid, Data) ->
+    get_indecies(get_selected_items(Grid, -1, []), Data).
+get_selected_items(Grid, Index, ItemAcc) ->
+    Item = wxListCtrl:getNextItem(Grid, Index,
+				  [{geometry, ?wxLIST_NEXT_ALL},
+				   {state, ?wxLIST_STATE_SELECTED}]),
+    case Item of
+	-1 ->
+	    lists:reverse(ItemAcc);
+	_ ->
+	    get_selected_items(Grid, Item, [Item | ItemAcc])
+    end.
+
+get_indecies(Items, Data) ->
+    get_indecies(Items, 0, Data).
+get_indecies([I|Rest], I, [H|T]) ->
+    [H|get_indecies(Rest, I+1, T)];
+get_indecies(Rest = [_|_], I, [_|T]) ->
+    get_indecies(Rest, I+1, T);
+get_indecies(_, _, _) ->
+    [].
+
+portinfo_available(NodeName) ->
+    _ = rpc:call(NodeName, code, ensure_loaded, [observer_backend]),
+    case rpc:call(NodeName, erlang, function_exported,
+                  [observer_backend, get_port_list, 0]) of
+        true  -> true;
+        false -> false
+    end.
+
+popup_unavailable_info(NodeName) ->
+    self() ! {info, {port_info_not_available, NodeName}},
+    ok.
+
+f(F, A) ->
+    lists:flatten(io_lib:format(F, A)).
+
+d(F) ->
+    d(F, []).
+
+d(F, A) ->
+    d(get(debug), F, A).
+
+d(true, F, A) ->
+    io:format("[oswx] " ++ F ++ "~n", A);
+d(_, _, _) ->
+    ok.
+
+
diff --git a/lib/observer/src/observer_wx.erl b/lib/observer/src/observer_wx.erl
index 12ca63350d..04f725cb4e 100644
--- a/lib/observer/src/observer_wx.erl
+++ b/lib/observer/src/observer_wx.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2011-2017. All Rights Reserved.
+%% Copyright Ericsson AB 2011-2021. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -103,6 +103,7 @@ get_scale() ->
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 init(_Args) ->
+    %% put(debug, true),
     register(observer, self()),
     wx:new(),
     catch wxSystemOptions:setOption("mac.listctrl.always_use_generic", 1),
@@ -122,23 +123,30 @@ init(_Args) ->
 
 setup(#state{frame = Frame} = State) ->
     %% Setup Menubar & Menus
+    d("setup -> load-config"),
     Config = load_config(),
     Cnf = fun(Who) ->
                   proplists:get_value(Who, Config, #{})
           end,
+    d("setup -> create menu-bar"),
     MenuBar = wxMenuBar:new(),
 
+    d("setup -> get nodes"),
     {Nodes, NodeMenus} = get_nodes(),
     DefMenus = default_menus(NodeMenus),
+    d("setup -> create menus"),
     observer_lib:create_menus(DefMenus, MenuBar, default),
 
+    d("setup -> set menu-bar"),
     wxFrame:setMenuBar(Frame, MenuBar),
 
     %% Setup panels
+    d("setup -> panel setup"),
     Panel = wxPanel:new(Frame, []),
     Notebook = wxNotebook:new(Panel, ?ID_NOTEBOOK, [{style, ?wxBK_DEFAULT}]),
 
     %% System Panel
+    d("setup -> create system panel"),
     SysPanel = observer_sys_wx:start_link(Notebook, self(), Cnf(sys_panel)),
     wxNotebook:addPage(Notebook, SysPanel, "System", []),
 
@@ -167,59 +175,75 @@ setup(#state{frame = Frame} = State) ->
     %% the window size
 
     %% Perf Viewer Panel
+    d("setup -> create perf panel"),
     PerfPanel = observer_perf_wx:start_link(Notebook, self(), Cnf(perf_panel)),
     wxNotebook:addPage(Notebook, PerfPanel, "Load Charts", []),
 
     %% Memory Allocator Viewer Panel
+    d("setup -> create memory panel"),
     AllcPanel = observer_alloc_wx:start_link(Notebook, self(), Cnf(allc_panel)),
     wxNotebook:addPage(Notebook, AllcPanel, ?ALLOC_STR, []),
 
     %% App Viewer Panel
+    d("setup -> create app panel"),
     AppPanel = observer_app_wx:start_link(Notebook, self(), Cnf(app_panel)),
     wxNotebook:addPage(Notebook, AppPanel, "Applications", []),
 
     %% Process Panel
+    d("setup -> create process panel"),
     ProPanel = observer_pro_wx:start_link(Notebook, self(), Cnf(pro_panel)),
     wxNotebook:addPage(Notebook, ProPanel, "Processes", []),
 
     %% Port Panel
+    d("setup -> create port panel"),
     PortPanel = observer_port_wx:start_link(Notebook, self(), Cnf(port_panel)),
     wxNotebook:addPage(Notebook, PortPanel, "Ports", []),
 
+    %% Socket Panel
+    d("setup -> create socket panel"),
+    SockPanel = observer_sock_wx:start_link(Notebook, self(), Cnf(sock_panel)),
+    wxNotebook:addPage(Notebook, SockPanel, "Sockets", []),
+
     %% Table Viewer Panel
+    d("setup -> create table panel"),
     TVPanel = observer_tv_wx:start_link(Notebook, self(), Cnf(tv_panel)),
     wxNotebook:addPage(Notebook, TVPanel, "Table Viewer", []),
 
     %% Trace Viewer Panel
+    d("setup -> create trace panel"),
     TracePanel = observer_trace_wx:start_link(Notebook, self(), Cnf(trace_panel)),
     wxNotebook:addPage(Notebook, TracePanel, ?TRACE_STR, []),
 
     %% Force redraw (windows needs it)
+    d("setup -> refresh"),
     wxWindow:refresh(Panel),
     DoFreeze andalso wxWindow:thaw(Panel),
 
+    d("setup -> frame: raise"),
     wxFrame:raise(Frame),
+    d("setup -> frame: set focus"),
     wxFrame:setFocus(Frame),
 
     SysPid = wx_object:get_pid(SysPanel),
     SysPid ! {active, node()},
-    Panels = [{sys_panel, SysPanel, "System"},   %% In order
-              {perf_panel, PerfPanel, "Load Charts"},
-              {allc_panel, AllcPanel, ?ALLOC_STR},
-              {app_panel,  AppPanel, "Applications"},
-              {pro_panel, ProPanel, "Processes"},
-              {port_panel, PortPanel, "Ports"},
-              {tv_panel, TVPanel, "Table Viewer"},
+    Panels = [{sys_panel,   SysPanel,   "System"},   %% In order
+              {perf_panel,  PerfPanel,  "Load Charts"},
+              {allc_panel,  AllcPanel,  ?ALLOC_STR},
+              {app_panel,   AppPanel,   "Applications"},
+              {pro_panel,   ProPanel,   "Processes"},
+              {port_panel,  PortPanel,  "Ports"},
+              {sock_panel,  SockPanel,  "Sockets"},
+              {tv_panel,    TVPanel,    "Table Viewer"},
               {trace_panel, TracePanel, ?TRACE_STR}],
 
     UpdState = State#state{main_panel = Panel,
-			   notebook = Notebook,
-			   menubar = MenuBar,
+			   notebook   = Notebook,
+			   menubar    = MenuBar,
 			   status_bar = StatusBar,
 			   active_tab = SysPid,
-                           panels = Panels,
-			   node  = node(),
-			   nodes = Nodes
+                           panels     = Panels,
+			   node       = node(),
+			   nodes      = Nodes
 			  },
     %% Create resources which we don't want to duplicate
     SysFont = wxSystemSettings:getFont(?wxSYS_OEM_FIXED_FONT),
@@ -234,6 +258,7 @@ setup(#state{frame = Frame} = State) ->
 		    wxFont:new(SysFontSize, ?wxFONTFAMILY_MODERN, ?wxFONTSTYLE_NORMAL, ?wxFONTWEIGHT_NORMAL)
 	    end,
     put({font, fixed}, Fixed),
+    d("setup -> done"),
     UpdState.
 
 
@@ -829,3 +854,17 @@ is_rb_server_running(Node, LogState) ->
        undefined ->
 	   ok
    end.
+
+
+d(F) ->
+    d(F, []).
+
+d(F, A) ->
+    d(get(debug), F, A).
+
+d(true, F, A) ->
+    io:format("[owx] " ++ F ++ "~n", A);
+d(_, _, _) ->
+    ok.
+
+
diff --git a/lib/observer/test/Makefile b/lib/observer/test/Makefile
index a44e54fc52..1dc7a7e11b 100644
--- a/lib/observer/test/Makefile
+++ b/lib/observer/test/Makefile
@@ -19,6 +19,9 @@
 include $(ERL_TOP)/make/target.mk
 include $(ERL_TOP)/make/$(TARGET)/otp.mk
 
+SOCKET_MODULES = \
+	observer_socket_test
+
 MODULES =  \
 	observer_SUITE \
 	crashdump_viewer_SUITE \
@@ -28,7 +31,8 @@ MODULES =  \
 	client \
 	server \
 	crashdump_helper \
-	crashdump_helper_unicode
+	crashdump_helper_unicode \
+	$(SOCKET_MODULES)
 
 ERL_FILES= $(MODULES:%=%.erl)
 
@@ -51,6 +55,10 @@ ERL_COMPILE_FLAGS += +warnings_as_errors +nowarn_export_all
 
 EBIN = .
 
+TARGETS = $(MODULES:%=$(EBIN)/%.$(EMULATOR))
+SOCKET_TARGETS = $(SOCKET_MODULES:%=$(EBIN)/%.$(EMULATOR))
+
+
 # ----------------------------------------------------
 # Targets
 # ----------------------------------------------------
@@ -70,6 +78,10 @@ clean:
 
 docs:
 
+targets: $(TARGETS)
+socket_targets: $(SOCKET_TARGETS)
+
+
 # ----------------------------------------------------
 # Special targets
 # ----------------------------------------------------
diff --git a/lib/observer/test/observer_socket_test.erl b/lib/observer/test/observer_socket_test.erl
new file mode 100644
index 0000000000..960c8a65f6
--- /dev/null
+++ b/lib/observer/test/observer_socket_test.erl
@@ -0,0 +1,951 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2021-2021. All Rights Reserved.
+%%
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%% =======================================================================
+%% This is just a simple utility that sets of several socket connections
+%% and monitors. Data is exchanged.
+%% This done to make it possible to see that the socket sections of
+%% observer works.
+%% =======================================================================
+
+-module(observer_socket_test).
+
+-export([start/0]).
+
+-define(NUM_ACCEPTORS, 5).
+
+-define(MTAG,    42).
+-define(PRINT,   01).
+-define(REQUEST, 02).
+-define(REPLY,   03).
+
+-define(SOCKET_MONITOR, whereis(socket_monitor)).
+
+-define(MSG_DATA1, <<"This is test data 0123456789 0123456789 0123456789">>).
+-define(MSG_DATA2, <<"This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789">>).
+-define(MSG_DATA3, <<"This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+		     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+		     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+		     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+		     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+		     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+		     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+		     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+		     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+		     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789"
+                     "This is test data 0123456789 0123456789 0123456789">>).
+-define(DATA, ?MSG_DATA1).
+
+
+start() ->
+    put(sname, "starter"),
+    %% put(debug, true),
+    i("try start socket-monitor"),
+    SockMon = start_socket_monitor(),
+    i("try start server"),
+    Domain = inet,
+    Type   = stream,
+    Proto  = tcp,
+    {Server, SockAddr}  = start_server(Domain, Type, Proto),
+    i("try start client"),
+    Client = start_client(Domain, Type, Proto, SockAddr),
+    i("done"),
+    {SockMon, Server, Client}.
+
+
+
+%% =======================================================================
+%% Socket Monitor
+%% =======================================================================
+
+start_socket_monitor() ->
+    Self = self(),
+    {SockMon, MRef} = spawn_monitor(fun() -> socket_monitor_start(Self) end),
+    receive
+	{'DOWN', MRef, process, SockMon, Reason} ->
+	    e("received unexpected down message from socket-monitor:"
+	      "~n   ~p", [Reason]),
+	    exit({socket_monitor, Reason});
+	{SockMon, ready} ->
+	    SockMon
+    end.
+
+socket_monitor_start(Parent) ->
+    put(sname, "socket-monitor"),
+    put(debug, true),
+    erlang:register(socket_monitor, self()),
+    Parent ! {self(), ready},
+    %% i("started"),
+    socket_monitor_loop(#{}).
+
+
+socket_monitor_loop(State) ->
+    receive
+	{'DOWN', MRef, Kind, Sock, Info} when (Kind =:= socket) orelse
+					      (Kind =:= port) ->
+	    {{Sock, SockStr, _Pid}, State2} = maps:take(MRef, State),
+	    i("received (socket) DOWN message: ~s"
+	      "~n   ~p", [SockStr, Info]),
+	    socket_monitor_loop(State2);
+
+	{monitor, Sock, SockStr, Fun, Pid} ->
+	    i("request to monitor socket: ~s", [SockStr]),
+	    MRef = Fun(Sock),
+	    socket_monitor_loop(State#{MRef => {Sock, SockStr, Pid}})
+    end.
+
+
+
+%% =======================================================================
+%% Server
+%% The server(s) processes are implemented on plain socket.
+%% =======================================================================
+
+start_server(Domain, Type, Proto) ->
+    Self = self(),
+    {Listener, MRef} =
+	spawn_monitor(fun() ->
+			      listener_start(Self, Domain, Type, Proto)
+		      end),
+    receive
+	{'DOWN', MRef, process, Listener, Reason} ->
+	    e("received unexpected down message from listener:"
+	      "~n   ~p", [Reason]),
+	    exit({listener, Reason});
+	{Listener, ready, SockAddr} ->
+	    {Listener, SockAddr}
+    end.
+
+
+listener_start(Parent, Domain, Type, Proto)
+  when (Type =:= stream) andalso (Proto =:= tcp) ->
+    put(sname, "listener"),
+    %% put(debug, true),
+    i("starting"),
+    LSock     = listener_create_lsock(Domain, Type, Proto),
+    LSM       = socket:monitor(LSock),
+    ?SOCKET_MONITOR !
+	{monitor, LSock, string_of(socket, LSock),
+	 sockmon_fun(socket), self()},
+    Acceptors = listener_create_acceptors(LSock),
+    {ok, SockAddr} = socket:sockname(LSock),
+    Parent ! {self(), ready, SockAddr},
+    i("started"),
+    listener_loop(#{lsock => LSock, lmon => LSM, accs => Acceptors}).
+
+listener_loop(#{lsock := Sock} = State) ->
+    receive
+	{'DOWN', _MRef, socket, Sock, Reason} ->
+	    e("unexpected (socket) down received: "
+	      "~n   ~p", [Reason]),
+	    listener_exit(socket_down, Reason);
+
+	{'DOWN', _MRef, process, Pid, Reason} ->
+	    i("unexpected (process ~p) down received: "
+	      "~n   ~p", [Pid, Reason]),
+	    listener_loop(listener_handle_down(State, Pid, Reason))
+    end.
+
+listener_handle_down(#{lsock := LSock, accs := Acceptors0} = State,
+		     Pid, Reason) ->
+    case maps:remove(Pid, Acceptors0) of
+	Acceptors0 ->
+	    i("unexpected down from unknown process ~p received: "
+	      "~n   ~p", [Pid, Reason]),
+	    State;
+	_Acceptors1 ->
+	    %% We could create a new acceptor here, but we need to make
+	    %% sure we do not end up in a create-die loop, easier to just
+	    %% assume *they should never die*...
+	    e("unexpected down from acceptor process ~p received: "
+	      "~n   ~p", [Pid, Reason]),
+	    (catch socket:close(LSock)),
+	    listener_exit(acceptor_down, Reason)
+    end.
+
+listener_create_lsock(Domain, Type, Proto) ->
+    i("try extract local address"),
+    Addr = case which_local_addr(Domain) of
+	       {ok, A} ->
+		   A;
+	       {error, Reason} ->
+		   listener_exit(failed_local_addr, Reason)
+	   end,
+    i("try create socket"),
+    LSock = case socket:open(Domain, Type, Proto) of
+		{ok, S} ->
+		    S;
+		{error, Reason1} ->
+		    listener_exit(failed_socket_open, Reason1)
+	    end,
+    i("try bind socket"),
+    case socket:bind(LSock, #{family => Domain,
+			      addr   => Addr,
+			      port   => 0}) of
+	ok ->
+	    ok;
+	{error, Reason2} ->
+	    listener_exit(failed_socket_bind, Reason2)
+    end,
+    i("try make listen socket"),
+    case socket:listen(LSock, 10) of
+	ok ->
+	    ok;
+	{error, Reason3} ->
+	    listener_exit(failed_socket_listen, Reason3)
+    end,
+    i("listen socket created"),
+    LSock.
+
+
+listener_create_acceptors(LSock) ->
+    listener_create_acceptors(LSock, 1, []).
+
+listener_create_acceptors(_LSock, ID, Acc) when (ID > ?NUM_ACCEPTORS) ->
+    maps:from_list(Acc);
+listener_create_acceptors(LSock, ID, Acc) ->
+    i("try create acceptor ~w", [ID ]),
+    Acceptor = listener_create_acceptor(LSock, ID),
+    listener_create_acceptors(LSock, ID+1, [Acceptor|Acc]).
+
+listener_create_acceptor(LSock, ID) ->
+    Self     = self(),
+    Acceptor = {Pid, MRef} =
+	spawn_monitor(fun() -> acceptor_start(Self, LSock, ID) end),
+    receive
+	{'$socket', LSock, abort, Info} ->
+	    e("received unexpected select abort: "
+	      "~n   ~p", [Info]),
+	    listener_exit(abort, Info);
+
+	{'DOWN', MRef, process, Pid, Reason} ->
+	    e("received unexpected acceptor ~w down: "
+	      "~n   ~p", [ID, Reason]),
+	    listener_exit(acceptor_start, Reason);
+
+	{Pid, ready} ->
+	    i("received expected acceptor ~w ready", [ID]),
+	    Acceptor
+    end.
+
+listener_exit(Tag, Reason) ->
+    exit({listener, Tag, Reason}).
+
+
+%% ---
+
+acceptor_start(Listener, LSock, ID) ->
+    put(sname, f("acceptor[~w]", [ID])),
+    %% put(debug, true),
+    MRef = erlang:monitor(process, Listener),
+    Listener ! {self(), ready},
+    i("started"),
+    acceptor_loop(#{id       => ID,
+		    hid      => 1,
+		    listener => {Listener, MRef},
+		    lsock    => LSock,
+		    select   => undefined,
+		    handlers => []}).
+
+acceptor_loop(#{select := undefined} = State) ->
+    acceptor_loop(acceptor_try_accept(State));
+
+acceptor_loop(State) ->
+    acceptor_loop(acceptor_try_select(State)).
+
+acceptor_try_accept(#{lsock := LSock} = State) ->
+    i("try accept (nowait)"),
+    case socket:accept(LSock, nowait) of
+	{ok, ASock} ->
+	    %% i("accepted - spawn handler"),	
+	    ?SOCKET_MONITOR !
+		{monitor, ASock, string_of(socket, ASock),
+		 sockmon_fun(socket), self()},
+	    acceptor_create_handler(State, ASock);
+	{select, SelectInfo} ->
+	    %% i("selected:"
+	    %%   "~n   ~p", [SelectInfo]),
+	    State#{select => SelectInfo};
+	{error, Reason} ->
+	    e("accept failed: "
+	      "~n   ~p", [Reason]),
+	    acceptor_exit(State, accept, Reason)
+    end.
+
+
+acceptor_try_select(
+  #{lsock    := LSock,
+    listener := {Listener, MRef},
+    select   := {select_info, _, Info} = SelectInfo} = State) ->
+    i("await select message"),
+    receive
+	{'$socket', LSock, abort, Info} ->
+	    e("received unexpected select abort: "
+	      "~n   ~p", [Info]),
+	    acceptor_exit(State, abort, Info);
+
+	{'$socket', LSock, select, Info} ->
+	    i("received select message: "
+	      "~n   ~p", [Info]),
+	    case socket:accept(LSock) of
+		{ok, ASock} ->
+		    %% i("accepted - spawn handler"),
+		    ?SOCKET_MONITOR !
+			{monitor, ASock, string_of(socket, ASock),
+			 sockmon_fun(socket), self()},
+		    acceptor_create_handler(State#{select => undefined},
+					    ASock);
+		{error, Reason} ->
+		    e("accept failed: "
+		      "~n   ~p", [Reason]),
+		    %% This is a bit overkill, but just to be on the safe side
+		    (catch socket:cancel(LSock, SelectInfo)),
+		    acceptor_exit(State, post_select_accept, Reason)
+	    end;
+
+	{'DOWN', MRef, process, Listener, Reason} ->
+	    e("listener down received: "
+	      "~n   ~p", [Reason]),
+	    (catch socket:cancel(LSock, SelectInfo)),
+	    acceptor_exit(State, listener, Reason);
+
+	{'DOWN', _MRef, process, _Pid, {{handler,_,_HID},recv,normal}} ->
+	    %% i("received normal exit from handler ~w (~p)", [_HID, _Pid]),
+	    acceptor_try_select(State);
+
+	Any ->
+	    i("received unexpected message: "
+	      "~n   ~p"
+	      "~nwhen"
+	      "~n   LSock: ~p"
+	      "~n   Info:  ~p", [Any, LSock, Info]),
+	    acceptor_try_select(State)
+
+    end.
+
+
+acceptor_create_handler(#{listener := {Listener, MRef},
+			  hid      := HID} = State, ASock) ->
+    Self    = self(),
+    _Handler = {HPid, HMRef} =
+	spawn_monitor(fun() -> handler_start(Self, HID) end),
+    receive
+	{'$socket', ASock, abort, Info} ->
+	    e("received unexpected select abort: "
+	      "~n   ~p", [Info]),
+	    acceptor_exit(State, abort, Info);
+
+	{'DOWN', MRef, process, Listener, Reason} ->
+	    e("listener down received: "
+	      "~n   ~p", [Reason]),
+	    exit(HPid, kill),
+	    acceptor_exit(State, listener, Reason);
+
+	{'DOWN', HMRef, process, HPid, Reason} ->
+	    e("new handler (~p) down received: "
+	      "~n   ~p", [HPid, Reason]),
+	    acceptor_exit(State, handler, Reason);
+
+	{HPid, ready} ->
+	    case socket:setopt(ASock, otp, controlling_process, HPid) of
+		ok ->
+		    HPid ! {continue, ASock},
+		    State#{hid => HID+1};
+		{error, Reason} ->
+		    e("failed changing controlling process: "
+		      "~n   ~p", [Reason]),
+		    (catch socket:close(ASock)),
+		    exit(HPid, kill),
+		    acceptor_exit(State, failed_changing_ctrl_proc, Reason)
+	    end
+    end.
+    
+
+acceptor_exit(#{id := ID}, Tag, Reason) ->
+    exit({{acceptor, ID}, Tag, Reason}).
+
+
+%% ---
+
+handler_start(Parent, ID) ->
+    put(sname, f("handler[~w]", [ID])),
+    %% put(debug, true),
+    i("starting"),
+    MRef = erlang:monitor(process, Parent),
+    Parent ! {self(), ready},
+    receive
+	{'DOWN', MRef, process, Parent, Reason} ->
+	    e("parent (~p) down received: "
+	      "~n   ~p", [Parent, Reason]),
+	    handler_exit(#{id => undefined, parent => {Parent, undefined}},
+			 parent, Reason);
+
+	{continue, Sock} ->
+	    i("started"),
+	    handler_loop(#{id     => ID,
+			   parent => {Parent, MRef},
+			   sock   => Sock,
+			   select => undefined,
+			   buf    => <<>>})
+    end.
+
+
+handler_loop(#{select := undefined} = State) ->
+    handler_loop(handler_try_read(State));
+handler_loop(State) ->
+    handler_loop(handler_try_select(State)).
+
+
+handler_try_read(#{sock := Sock} = State) ->
+    case socket:recv(Sock) of
+	{ok, Data} ->
+	    handler_process_data(State, Data);
+	{select, SelectInfo} ->
+	    State#{select => SelectInfo};
+	{error, closed} ->
+	    i("recv got closed => client done"),
+	    handler_exit(State, recv, normal);
+	{error, Reason} ->
+	    e("recv failed: "
+	      "~n   ~p", [Reason]),
+	    (catch socket:close(Sock)),
+	    handler_exit(State, recv, Reason)
+    end.
+
+handler_try_select(
+  #{sock   := Sock,
+    parent := {Parent, MRef},
+    select := {select_info, _, Info} = SelectInfo} = State) ->
+    receive
+	{'$socket', Sock, abort, Info} ->
+	    e("received unexpected select abort: "
+	      "~n   ~p", [Info]),
+	    handler_exit(State, abort, Info);
+
+	{'$socket', Sock, select, Info} ->
+	    case socket:recv(Sock) of
+		{ok, Data} ->
+		    handler_process_data(State, Data);
+		{error, Reason} ->
+		    i("recv failed: "
+		      "~n   ~p", [Reason]),
+		    (catch socket:close(Sock)),
+		    handler_exit(State, recv, Reason)
+	    end;
+	{'DOWN', MRef, process, Parent, Reason} ->
+	    e("parent down received: "
+	      "~n   ~p", [Reason]),
+	    (catch socket:cancel(Sock, SelectInfo)),
+	    handler_exit(State, parent, Reason)
+    end.
+
+handler_process_data(#{buf := <<>>} = State, NewData) ->
+    handler_process_data(State#{buf => NewData});
+handler_process_data(State, <<>>) ->
+    handler_process_data(State);
+handler_process_data(#{buf := Buf} = State, NewData) ->
+    handler_process_data(State#{buf => <<Buf/binary, NewData/binary>>}).
+
+handler_process_data(#{buf := <<?MTAG:32,
+			       ID:32,
+			       TYPE:32,
+			       SZ:32,
+			       Data:SZ/binary,
+			       Rest/binary>>} = State) ->
+    handler_process_data(State, ID, TYPE, Data),
+    handler_process_data(State#{buf => Rest});
+handler_process_data(State) ->
+    State.
+
+
+handler_process_data(_State, ID, ?PRINT, Data) ->
+    i("~w: print"
+      "~n   ~p", [ID, erlang:binary_to_list(Data)]);
+handler_process_data(#{sock := Sock} = State, ID, ?REQUEST, Data) ->
+    SZ = size(Data),
+    Reply = <<?MTAG:32, ID:32, ?REPLY:32, SZ:32, Data/binary>>,
+    case socket:send(Sock, Reply) of
+	ok ->
+	    ok;
+	{error, Reason} ->
+	    e("failed sending reply for request ~w: "
+	      "~n   ~p", [ID, Reason]),
+	    (catch socket:close(Sock)),
+	    handler_exit(State, recv, Reason)
+    end.
+
+handler_exit(#{id := ID, parent := {Pid, _}}, Tag, Reason) ->
+    exit({{handler, Pid, ID}, Tag, Reason}).
+
+
+%% =======================================================================
+%% Client
+%% Of the client(s), one is implemented on gen_tcp with
+%% inet_backend = socket and the other with inet_backend = inet.
+%% The clients run for a period of 30 sec - 2 min, and then die.
+%% Then a new is created!
+%% Each client sends simple requests (with some dummy date), and
+%% also once every 15 seconds an 'print' message (which the server
+%% is to simply print the data (which is supposed to be a string).
+%% =======================================================================
+
+start_client(Domain, Type, Proto, ServerSockAddr) ->
+    Self = self(),
+    Client = {Pid, MRef} =
+	spawn_monitor(fun() ->
+			      client_ctrl_start(Self,
+						Domain, Type, Proto,
+						ServerSockAddr)
+		      end),
+    receive
+	{'DOWN', MRef, process, Pid, Reason} ->
+	    e("received unexpected down message from client (~p):"
+	      "~n   ~p", [Pid, Reason]),
+	    exit({client, Reason});
+
+	{Pid, ready} ->
+	    i("received expected ready from client"),
+	    Client
+    end.
+
+
+client_ctrl_start(Parent,
+		  Domain, Type, Proto,
+		  ServerSockAddr) ->
+    put(sname, "client-ctrl"),
+    %% put(debug, true),
+    State0 = #{parent   => Parent,
+	       domain   => Domain,
+	       type     => Type,
+	       protocol => Proto,
+	       server   => ServerSockAddr,
+	       cid      => 1,
+	       clients  => #{}},
+    State1 = start_client(State0, socket),
+    State2 = start_client(State1, inet),
+    Parent ! {self(), ready},
+    i("started"),
+    client_ctrl_loop(State2).
+
+
+client_ctrl_loop(State) ->
+    receive
+	{'DOWN', MRef, process, Pid, Reason} ->
+	    client_ctrl_loop(client_ctrl_handle_down(State, MRef, Pid, Reason))
+    end.
+
+client_ctrl_handle_down(#{clients := Clients0} = State,
+			MRef, Pid, Reason) ->
+    case maps:take(Pid, Clients0) of
+	{{ID, MRef, Backend}, Clients1} ->
+	    i("received down from ~w-client ~w (~p): "
+	      "~n   ~p", [Backend, ID, Pid, Reason]),
+	    start_client(State#{clients => Clients1}, Backend);
+	error ->
+	    i("received down from unknown process ~p: "
+	      "~n   ~p", [Pid, Reason]),
+	    State
+    end.
+    
+client_ctrl_exit(Tag, Reason) ->
+    exit({'client-ctrl', Tag, Reason}).
+
+
+start_client(#{domain   := Domain,
+	       type     := Type,
+	       protocol := Proto,
+	       server   := #{addr := Addr, port := Port},
+	       cid      := ID,
+	       clients  := Clients0} = State, Backend) ->
+    Self = self(),
+    i("try start client ~w", [ID]),
+    LifeTime = rand:uniform(timer:minutes(3)) + timer:minutes(2),
+    {Pid, MRef} =
+	spawn_monitor(fun() ->
+			      client_start(Self,
+					   Backend, ID,
+					   LifeTime,
+					   Domain, Type, Proto,
+					   Addr, Port)
+		      end),
+    receive
+	{'DOWN', MRef, process, Pid, Reason} ->
+	    e("received unexpected down message from client ~w (~p):"
+	      "~n   ~p", [ID, Pid, Reason]),
+	    client_ctrl_exit({client, ID}, Reason);
+
+	{Pid, ready} ->
+	    i("received expected ready from client ~w (~p)", [ID, Pid]),
+	    Clients1 = Clients0#{Pid => {ID, MRef, Backend}},
+	    State#{cid => ID + 1, clients => Clients1}
+    end.
+
+
+client_start(Parent, Backend, ID,
+	     LifeTime,
+	     Domain, Type, Proto,
+	     ServerAddr, ServerPort)
+  when (Type =:= stream) andalso (Proto =:= tcp) ->
+    put(sname, f("client[~w]", [ID])),
+    %% put(debug, true),
+    i("starting"),
+    erlang:send_after(LifeTime, self(), terminate),
+    State = client_connect(#{id          => ID,
+			     backend     => Backend,
+			     domain      => Domain,
+			     type        => Type,
+			     protocol    => Proto,
+			     server_addr => ServerAddr,
+			     server_port => ServerPort}),
+    MRef = erlang:monitor(process, Parent),
+    Parent ! {self(), ready},
+    i("started"),
+    client_loop(State#{condition => send_request,
+		       mid       => 1,
+		       parent    => Parent,
+		       mref      => MRef,
+		       buf       => <<>>}).
+
+
+client_connect(#{backend     := Backend,
+		 server_addr := ServerAddr,
+		 server_port := ServerPort} = State) ->
+    COpts = [{inet_backend, Backend}, {active, true}, binary],
+    i("[~w] try connect to ~s:~w",
+      [Backend, inet_parse:ntoa(ServerAddr), ServerPort]),
+    case gen_tcp:connect(ServerAddr, ServerPort, COpts) of
+	{ok, Sock} ->
+	    %% i("[~w] connected", [Backend]),
+	    ?SOCKET_MONITOR !
+		{monitor, Sock,
+		 string_of(inet, Sock),
+		 sockmon_fun(inet), self()},
+	    State#{sock => Sock};
+	{error, Reason} ->
+	    e("failed connecting: "
+	      "~n   ~p", [Reason]),
+	    client_exit(State, connect, Reason)
+    end.
+
+
+client_loop(#{condition := terminate,
+	      sock      := Sock}) ->
+    (catch gen_trcp:close(Sock)),
+    exit(normal);
+client_loop(#{condition := {await_reply, _MID},
+	      parent    := Parent,
+	      sock      := Sock} = State) ->
+    receive
+	{'DOWN', _MRef, process, Parent, Reason} ->
+	    e("unexpected down from parent received: "
+	      "~n   ~p", [Reason]),
+	    client_exit(State, parent_down, Reason);
+	
+	{tcp, Sock, Data} ->
+	    %% i("received (~w bytes of) data", [size(Data)]),
+	    client_loop(client_process_data(State, Data));
+
+	terminate ->
+	    client_loop(State#{condition => terminate})
+
+    end;
+client_loop(#{condition := send_request, sock := Sock, mid := MID} = State) ->
+    %% i("try send request ~w", [MID]),
+    Data = ?DATA,
+    SZ   = size(Data),
+    Req  = <<?MTAG:32, MID:32, ?REQUEST:32, SZ:32, Data/binary>>,
+    case gen_tcp:send(Sock, Req) of
+	ok ->
+	    client_loop(State#{condition => {await_reply, MID},
+			       mid => MID + 1});
+	{error, Reason} ->
+	    e("failed sending request ~w: "
+	      "~n   ~p", [MID, Reason]),
+	    client_exit(State, send, Reason)
+    end.
+
+
+client_process_data(#{condition := {await_reply, MID},
+		      buf       := Buf} = State, NewData) ->
+    case <<Buf/binary, NewData/binary>> of
+	<<?MTAG:32, MID:32, ?REPLY:32, SZ:32, _Data:SZ/binary, Rest/binary>> ->
+	    State#{condition => send_request, buf => Rest};
+	<<?MTAG:32, MID2:32, ?REPLY:32, SZ:32, _Data:SZ/binary, _Rest/binary>> ->
+	    client_exit(State, unexpected_msg, MID2);
+	NewBuf ->
+	    State#{buf => NewBuf}
+    end.
+
+client_exit(#{id := ID}, Tag, Reason) ->
+    exit({{client, ID}, Tag, Reason}).
+
+
+%% =======================================================================
+%% Utility
+%% =======================================================================
+
+%% This gets the local address (not {127, _} or {0, ...} or {16#fe80, ...})
+%% We should really implement this using the (new) net module,
+%% but until that gets the necessary functionality...
+which_local_addr(Domain) ->
+    case which_local_host_info(Domain) of
+        {ok, #{addr := Addr}} ->
+            {ok, Addr};
+        {error, _Reason} = ERROR ->
+            ERROR
+    end.
+    
+
+%% Returns the interface (name), flags and address (not 127...)
+%% of the local host.
+which_local_host_info(Domain) ->
+    case inet:getifaddrs() of
+        {ok, IFL} ->
+            which_local_host_info(Domain, IFL);
+        {error, _} = ERROR ->
+            ERROR
+    end.
+
+which_local_host_info(_Domain, []) ->
+    {error, no_address};
+which_local_host_info(Domain, [{"docker" ++ _, _}|IFL]) ->
+    which_local_host_info(Domain, IFL);
+which_local_host_info(Domain, [{"br-" ++ _, _}|IFL]) ->
+    which_local_host_info(Domain, IFL);
+which_local_host_info(Domain, [{Name, IFO}|IFL]) ->
+    case if_is_running_and_not_loopback(IFO) of
+        true ->
+            try which_local_host_info2(Domain, IFO) of
+                Info ->
+                    {ok, Info#{name => Name}}
+            catch
+                throw:_:_ ->
+                    which_local_host_info(Domain, IFL)
+            end;
+        false ->
+            which_local_host_info(Domain, IFL)
+    end;
+which_local_host_info(Domain, [_|IFL]) ->
+    which_local_host_info(Domain, IFL).
+
+if_is_running_and_not_loopback(If) ->
+    lists:keymember(flags, 1, If) andalso
+        begin
+            {value, {flags, Flags}} = lists:keysearch(flags, 1, If),
+            (not lists:member(loopback, Flags)) andalso
+                lists:member(running, Flags)
+        end.
+
+
+which_local_host_info2(inet = _Domain, IFO) ->
+    Addr      = which_local_host_info3(addr,  IFO,
+                                       fun({A, _, _, _}) when (A =/= 127) -> true;
+                                          (_) -> false
+                                       end),
+    NetMask   = which_local_host_info3(netmask,  IFO,
+                                       fun({_, _, _, _}) -> true;
+                                          (_) -> false
+                                       end),
+    BroadAddr = which_local_host_info3(broadaddr,  IFO,
+                                       fun({_, _, _, _}) -> true;
+                                          (_) -> false
+                                       end),
+    Flags     = which_local_host_info3(flags, IFO, fun(_) -> true end),
+    #{flags     => Flags,
+      addr      => Addr,
+      broadaddr => BroadAddr,
+      netmask   => NetMask};
+which_local_host_info2(inet6 = _Domain, IFO) ->
+    Addr    = which_local_host_info3(addr,  IFO,
+                                     fun({A, _, _, _, _, _, _, _}) 
+                                           when (A =/= 0) andalso 
+                                                (A =/= 16#fe80) -> true;
+                                        (_) -> false
+                                     end),
+    NetMask = which_local_host_info3(netmask,  IFO,
+                                       fun({_, _, _, _, _, _, _, _}) -> true;
+                                          (_) -> false
+                                       end),
+    Flags   = which_local_host_info3(flags, IFO, fun(_) -> true end),
+    #{flags   => Flags,
+      addr    => Addr,
+      netmask => NetMask}.
+
+which_local_host_info3(_Key, [], _) ->
+    throw({error, no_address});
+which_local_host_info3(Key, [{Key, Val}|IFO], Check) ->
+    case Check(Val) of
+        true ->
+            Val;
+        false ->
+            which_local_host_info3(Key, IFO, Check)
+    end;
+which_local_host_info3(Key, [_|IFO], Check) ->
+    which_local_host_info3(Key, IFO, Check).
+
+
+%% ---
+
+string_of(socket = _Backend, Socket) ->
+    socket:to_list(Socket);
+string_of(inet = _Backend, Socket) ->
+    inet:socket_to_list(Socket).
+
+
+sockmon_fun(socket = _Backend) ->
+    fun(Sock) -> socket:monitor(Sock) end;
+sockmon_fun(inet = _Backend) ->
+    fun(Sock) -> inet:monitor(Sock) end.
+	    
+
+%% ---
+
+
+
+%% ---
+
+f(F, A) ->
+    lists:flatten(io_lib:format(F, A)).
+
+
+formated_timestamp() ->
+    format_timestamp(os:timestamp()).
+
+format_timestamp({_N1, _N2, N3} = TS) ->
+    {_Date, Time}  = calendar:now_to_local_time(TS),
+    {Hour,Min,Sec} = Time,
+    FormatTS = io_lib:format("~.2.0w:~.2.0w:~.2.0w.4~w",
+                             [Hour, Min, Sec, round(N3/1000)]),  
+    lists:flatten(FormatTS).
+
+
+e(F, A) ->
+    p(true, "<ERROR> ", F, A).
+
+i(F) ->
+    i(F, []).
+
+i(F, A) ->
+    p(get(debug), "", F, A).
+
+p(true, PRE, F, A) ->
+    io:format("[ ~s, ~s ] ~s" ++ F ++ "~n",
+	      [formated_timestamp(), get(sname), PRE | A]);
+p(_, _, _, _) ->
+    ok.
+
diff --git a/lib/runtime_tools/src/observer_backend.erl b/lib/runtime_tools/src/observer_backend.erl
index e38757b939..871bfc54da 100644
--- a/lib/runtime_tools/src/observer_backend.erl
+++ b/lib/runtime_tools/src/observer_backend.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 2002-2018. All Rights Reserved.
+%% Copyright Ericsson AB 2002-2021. All Rights Reserved.
 %% 
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -23,7 +23,8 @@
 -export([vsn/0]).
 
 %% observer stuff
--export([sys_info/0, get_port_list/0, procs_info/1,
+-export([socket_info/0,
+	 sys_info/0, get_port_list/0, get_socket_list/0, procs_info/1,
 	 get_table/3, get_table_list/2, fetch_stats/2]).
 
 %% etop stuff
@@ -51,6 +52,16 @@ vsn() ->
 %%
 %% observer backend
 %%
+
+socket_info() ->
+    Info0             = socket:info(),
+    {Counters, Info1} = maps:take(counters, Info0),
+    IovMax            = maps:get(iov_max , Info1),
+    NumMons           = socket:number_of_monitors(),
+    [{iov_max, IovMax}, {num_monitors, NumMons} | maps:to_list(Counters)].
+    
+
+
 sys_info() ->
     MemInfo = try erlang:memory() of
 		  Mem -> Mem
@@ -203,6 +214,77 @@ inet_port_extra({_,Type},Port) when Type =:= "udp_inet";
 inet_port_extra(_,_) ->
     [].
 
+
+get_socket_list() ->
+    [begin
+	 Kind  = socket:which_socket_kind(S),
+	 FD    = case socket:getopt(S, otp, fd) of
+		     {ok, FD0} ->
+			 FD0;
+		     _ ->
+			 -1
+		 end,
+	 Info0  = socket:info(S),
+	 d("get_socket_list -> info: "
+	   "~n   ~p", [Info0]),
+	 IdStr0 = socket:to_list(S),
+	 IdStr  = case Info0 of
+		      #{type     := stream,
+			protocol := tcp} when (Kind =:= compat) ->
+			  %% Faketi fake
+			  "#Socket" ++ Id = IdStr0,
+			  "#InetSocket" ++ Id;
+		      _ ->
+			  IdStr0
+		  end,
+	 {Counters0, Info1} = maps:take(counters, Info0),
+	 Counters = maps:to_list(Counters0),
+	 d("get_socket_list -> Counters: "
+	   "~n   ~p", [Counters]),
+	 Info2 = maps:remove(ctype,         Info1),
+	 Info3 = maps:remove(num_acceptors, Info2),
+	 Info4 = maps:remove(num_readers,   Info3),
+	 Info5 = maps:remove(num_writers,   Info4),
+	 Info6 =
+	     case socket:peername(S) of
+		 {ok, RAddr} ->
+		     RAddrStr = sockaddr_to_list(RAddr),
+		     maps:put(raddress, RAddrStr, Info5);
+		 _ ->
+		     Info5
+	     end,
+	 Info7 =
+	     case socket:sockname(S) of
+		 {ok, LAddr} ->
+		     LAddrStr = sockaddr_to_list(LAddr),
+		     maps:put(laddress, LAddrStr, Info6);
+		 _ ->
+		     Info6
+	     end,
+	 Info7#{id           => S,
+		id_str       => IdStr,
+		fd           => FD,
+		kind         => Kind,
+		monitored_by => socket:monitored_by(S),
+		statistics   => Counters}
+     end || S <- socket:which_sockets()].
+
+sockaddr_to_list(#{family := local, path := PathBin}) when is_binary(PathBin) ->
+    erlang:binary_to_list(PathBin);
+sockaddr_to_list(#{family := local, path := Path}) when is_list(Path) ->
+    Path;
+sockaddr_to_list(#{family := inet, addr := Addr, port := Port}) ->
+    inet_parse:ntoa(Addr) ++ " : " ++ erlang:integer_to_list(Port);
+sockaddr_to_list(#{family := inet6, addr := Addr, port := Port,
+		   flowinfo := FI, scope_id := SID}) ->
+    inet_parse:ntoa(Addr) ++ " : " ++
+	erlang:integer_to_list(Port) ++ 
+	" , " ++ erlang:integer_to_list(FI) ++
+	" , " ++ erlang:integer_to_list(SID);
+sockaddr_to_list(Addr) ->
+    f("~p", [Addr]).
+    
+
 get_table_list(ets, Opts) ->
     HideUnread = proplists:get_value(unread_hidden, Opts, true),
     HideSys = proplists:get_value(sys_hidden, Opts, true),
@@ -793,3 +875,19 @@ mnesia_tables() ->
 
 ignore(true, Reason) -> throw(Reason);
 ignore(_,_ ) -> ok.
+
+f(F, A) ->
+    lists:flatten(io_lib:format(F, A)).
+
+%% d(F) ->
+%%     d(F, []).
+
+d(F, A) ->
+    d(get(debug), F, A).
+
+d(true, F, A) ->
+    io:format("[ob] " ++ F ++ "~n", A);
+d(_, _, _) ->
+    ok.
+
+
-- 
2.26.2

Places

File 1041-observer-runtime_tools-Add-a-tab-for-sockets.patch of Package erlang (Revision 63ff62e87690e42782ca999e9a4b568d)

Places