Use Process.label() instead of Process.register(). (#1071)

* Use Process.label() instead of Process.register(). Deprecate :components option for :unsafely_name_processes_for_stalker

* Add report_links_to_observer config option in favour of deprecated unsafely_name_processes_for_observer: [:links]

* Update required Elixir version

* Remove quote

---------

Co-authored-by: Mateusz Front <mateusz.front@swmansion.com>

Author: varsill

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Latest
 * Improve remove_link action docs
+* Deprecate `:components` option for `:unsafely_name_processes_for_observer`
+* Deprecate `:links` option for `:unsafely_name_processes_for_observer` in favour of `:report_links_to_observer` configuration entry
+* [Set label](https://hexdocs.pm/elixir/Process.html#set_label/1) for all the Membrane processes (i.e. for both Membrane components like pipelines, elements and bins and for utility components like subprocess supervisors)
+* Update required Elixir version to `~> 1.17`
 
 ## 1.2.6
  * Add tutorials [#1007](https://github.com/membraneframework/membrane_core/pull/1007), plugins [#1012](https://github.com/membraneframework/membrane_core/pull/1012) and demos [#1013](https://github.com/membraneframework/membrane_core/pull/1013) to the docs.

assets/images/observer_graph.png

@@ -28,7 +28,7 @@ defmodule Membrane.ComponentPath do
   """
   @spec format(path()) :: String.t()
   def format(path) do
-    Enum.join(path)
+    Enum.join(path, "/")
   end
 
   @doc """

lib/membrane/component_path.ex

@@ -106,12 +106,12 @@ defmodule Membrane.Core.Bin do
     observability_config = %{
       name: name,
       component_type: :bin,
-      pid: self(),
       parent_path: options.parent_path,
       log_metadata: options.log_metadata
     }
 
     Membrane.Core.Stalker.register_component(options.stalker, observability_config)
+
     SubprocessSupervisor.set_parent_component(options.subprocess_supervisor, observability_config)
 
     {:ok, clock_proxy} =

lib/membrane/core/bin.ex

@@ -112,7 +112,6 @@ defmodule Membrane.Core.Element do
     observability_config = %{
       name: options.name,
       component_type: :element,
-      pid: self(),
       parent_path: options.parent_path,
       log_metadata: options.log_metadata
     }

lib/membrane/core/element.ex

@@ -31,13 +31,14 @@ defmodule Membrane.Core.Pipeline do
 
   defp do_init(params) do
     observability_config = %{
-      name: params.name,
-      component_type: :pipeline,
-      pid: self()
+      name: params.name || "Pipeline#{:erlang.pid_to_list(self())}",
+      component_type: :pipeline
     }
 
     %{subprocess_supervisor: subprocess_supervisor} = params
+
     SubprocessSupervisor.set_parent_component(subprocess_supervisor, observability_config)
+
     stalker = Stalker.new(observability_config, subprocess_supervisor)
 
     {:ok, resource_guard} =

lib/membrane/core/pipeline.ex

@@ -42,8 +42,10 @@ defmodule Membrane.Core.Pipeline.Supervisor do
     subprocess_supervisor = SubprocessSupervisor.start_link!()
 
     with {:ok, pipeline} <- start_fun.(subprocess_supervisor) do
+      name = name || "Pipeline#{:erlang.pid_to_list(pipeline)}"
+
       Membrane.Core.Stalker.setup_component_utility(
-        %{name: name, component_type: :pipeline, pid: pipeline},
+        %{name: name, component_type: :pipeline},
         "Pipeline supervisor"
       )
 

lib/membrane/core/pipeline/supervisor.ex

@@ -12,6 +12,12 @@ defmodule Membrane.Core.Stalker do
                                           []
                                         )
 
+  @report_links_to_observer Application.compile_env(
+                              :membrane_core,
+                              :report_links_to_observer,
+                              false
+                            )
+
   @metrics_enabled Application.compile_env(:membrane_core, :enable_metrics, true)
 
   @scrape_interval 1000
@@ -25,8 +31,7 @@ defmodule Membrane.Core.Stalker do
           optional(:parent_path) => ComponentPath.path(),
           optional(:log_metadata) => Logger.metadata(),
           name: Membrane.Child.name(),
-          component_type: :element | :bin | :pipeline,
-          pid: pid()
+          component_type: :element | :bin | :pipeline
         }
 
   @type link_observability_data :: %{
@@ -117,9 +122,7 @@ defmodule Membrane.Core.Stalker do
   end
 
   # Sets component path, logger metadata and adds necessary entries to the process dictionary
-  # Also registers the process with a meaningful name for easier introspection with
-  # stalker if enabled by setting `unsafely_name_processes_for_observer: :components`
-  # in config.exs.
+  # and labels the process with a meaningful name for easier introspection with stalker
   defp setup_process_local_observability(config, opts) do
     config = parse_observability_config(config, opts)
 
@@ -132,7 +135,7 @@ defmodule Membrane.Core.Stalker do
       do: Process.put(:__membrane_pipeline__, true)
 
     Logger.metadata(config.log_metadata)
-    register_name_for_stalker(config)
+    set_label(config)
 
     ComponentPath.set(config.component_path)
 
@@ -144,54 +147,36 @@ defmodule Membrane.Core.Stalker do
   defp parse_observability_config(config, opts) do
     utility_name = Map.get(opts, :utility_name)
     stalker = Map.get(opts, :stalker)
-    %{name: name, component_type: component_type, pid: pid} = config
-    is_name_provided = name != nil
-    pid_string = pid |> :erlang.pid_to_list() |> to_string()
-    name = if is_name_provided, do: name, else: pid_string
+    %{name: name, component_type: component_type} = config
     is_utility = utility_name != nil
 
-    name_string = """
-    #{if is_binary(name) and String.valid?(name), do: name, else: inspect(name)}\
-    #{if component_type == :element, do: "", else: "/"}\
-    """
+    name_string = if is_binary(name) and String.valid?(name), do: name, else: inspect(name)
 
     %{
       stalker: stalker,
       name: name,
       name_string: name_string,
-      pid_string: pid_string,
       component_type: component_type,
-      is_name_provided: is_name_provided,
       is_utility: is_utility,
       utility_name: if(is_utility, do: " #{utility_name}", else: ""),
       component_path: Map.get(config, :parent_path, []) ++ [name_string],
       log_metadata: Map.get(config, :log_metadata, [])
     }
   end
 
-  if :components in @unsafely_name_processes_for_observer do
-    defp register_name_for_stalker(config) do
-      if Process.info(self(), :registered_name) == {:registered_name, []} do
-        Process.register(
-          self(),
-          """
-          ##{config.pid_string} #{if config.is_name_provided, do: config.name_string}\
-          #{unless config.is_name_provided, do: " (#{config.component_type})"}#{config.utility_name}"\
-          """
-          |> String.to_atom()
-        )
-      end
+  defp set_label(config) do
+    utility_str = if config.is_utility, do: "'s #{config.utility_name}", else: ""
+    component_path_str = ComponentPath.format(config.component_path)
 
-      :ok
-    end
-  else
-    defp register_name_for_stalker(_config), do: :ok
+    label = "#{component_path_str}#{utility_str}"
+
+    Process.set_label(label)
   end
 
   @doc """
   Generates observability data needed for reporting links and their metrics.
 
-  If optionally turned on by setting `unsafely_name_processes_for_observer: :links` in
+  If optionally turned on by setting `report_links_to_observer: true` in
   config.exs, starts processes to reflect pads structure in the process tree for visibility
   in Erlang observer.
   """
@@ -204,12 +189,29 @@ defmodule Membrane.Core.Stalker do
     }
   end
 
+  if :components in @unsafely_name_processes_for_observer do
+    IO.warn("""
+    Deprecated `:components` value for :unsafely_name_processes_for_observer` configuration.
+    Now the processes are always labeled so there is no need to use this option anymore.
+    """)
+  end
+
   if :links in @unsafely_name_processes_for_observer do
+    IO.warn("""
+    Deprecated `:links` value for `:unsafely_name_processes_for_observer` configuration.
+    Instead please use the following configuration:
+    ```
+    config :membrane_core, report_links_to_observer: true
+    ```
+    """)
+  end
+
+  if @report_links_to_observer do
     defp run_link_dbg_process(pad_ref, observability_data) do
       {:ok, observer_dbg_process} =
         Task.start_link(fn ->
           Process.flag(:trap_exit, true)
-          Process.register(self(), :"pad #{inspect(pad_ref)} #{:erlang.pid_to_list(self())}")
+          Process.set_label(self(), "pad #{inspect(pad_ref)} #{:erlang.pid_to_list(self())}")
           process_to_link = Map.get(observability_data, :observer_dbg_process)
           if process_to_link, do: Process.link(process_to_link)
 

lib/membrane/core/stalker.ex

@@ -45,11 +45,7 @@ defmodule Membrane.Pipeline do
   ### Visualizing the supervision tree
 
   Use the [Applications tab](https://www.erlang.org/doc/apps/observer/observer_ug#applications-tab) in Erlang's Observer GUI
-  (or the `Kino` library in Livebook) to visualize a pipeline's internal supervision tree. Use the following configuration for debugging purposes only:
-
-        config :membrane_core, unsafely_name_processes_for_observer: [:components]
-
-  This improves the readability of the Observer's process tree graph by naming the pipeline descendants, as demonstrated here:
+  (or the `Kino` library in Livebook) to visualize a pipeline's internal supervision tree.
 
   ![Observer graph](assets/images/observer_graph.png).
   """

lib/membrane/pipeline.ex

@@ -9,7 +9,7 @@ defmodule Membrane.Mixfile do
     [
       app: :membrane_core,
       version: @version,
-      elixir: "~> 1.12",
+      elixir: "~> 1.17",
       elixirc_paths: elixirc_paths(Mix.env()),
       description: "Membrane Multimedia Framework (Core)",
       dialyzer: dialyzer(),