Dec 21st: [PT] Keep track of your Steam Deck gaming with the Elastic Agent

Que tal usar Observability para algo diferente? Nesse post nós usaremos nossas ferramentas para monitorar como nossos jogos estão performando. Hoje nos exploraremos como usar o Elastic Agent para monitorar um Steam Deck, o que nos permitirá ver o que jogamos mais, o quanto de recurso eles usam e como a GPU está performando.

Nós iremos ver:

• Como instalar o Elastic Agent
• Configurar Integrations
• Usar a Custom API integration para coletar dados sobre a GPU
• Criar Kibana dashboards
• Importar e exportar dahsboards

Dados sobre os processos

A System Integration já coleta todos os dados que precisamos sobre os processos que estão rodando. Nós usaremos esses dados para ver quanto de recurso os processos usam e os jogos mais jogados.

GPU data

De modo geral Observability data não inclui dados sobre a performance da CPU ou GPU. É possível coletar dados de NVIDIA GPUs, mas o Steam Deck usa uma GPU AMD personalizada, e nós queremos botar a mão na massa também.

Linux distros normalmente incluem lm_sensors e ele está presente no Steam OS. Isso será suficiente para coletar toda a informação que precisamos.

Rodando sensors no meu Steam Deck, esse é o resultado:

nvme-pci-0100
Adapter: PCI adapter
Composite:    +45.9°C  (low  = -273.1°C, high = +82.8°C)
                       (crit = +84.8°C)
Sensor 1:     +45.9°C  (low  = -273.1°C, high = +65261.8°C)
 
BAT1-acpi-0
Adapter: ACPI interface
in0:           8.40 V  
curr1:         1.74 A  
 
amdgpu-pci-0400
Adapter: PCI adapter
vddgfx:      650.00 mV 
vddnb:       655.00 mV 
edge:         +44.0°C  
slowPPT:       7.12 W  (avg =  11.10 W, cap =  15.00 W)
fastPPT:      11.10 W  (cap =  15.00 W)
 
steamdeck_hwmon-isa-0000
Adapter: ISA adapter
PD Contract Voltage:   5.00 V  
System Fan:             0 RPM
Battery Temp:         +25.0°C  
PD Contract Current: 1000.00 mA 
 
acpitz-acpi-0
Adapter: ACPI interface
temp1:        +54.0°C  (crit = +105.0°C)

Tudo que precisamos está aqui, mas não no melhor formato para coletar esses dados. Então usaremos a versão em JSON, basta rodar sensors -j:

{
   "nvme-pci-0100":{
      "Adapter": "PCI adapter",
      "Composite":{
         "temp1_input": 31.850,
         "temp1_max": 82.850,
         "temp1_min": -273.150,
         "temp1_crit": 84.850,
         "temp1_alarm": 0.000
      },
      "Sensor 1":{
         "temp2_input": 31.850,
         "temp2_max": 65261.850,
         "temp2_min": -273.150
      }
   },
   "BAT1-acpi-0":{
      "Adapter": "ACPI interface",
      "in0":{
         "in0_input": 8.656
      },
      "curr1":{
         "curr1_input": 0.159
      }
   },
   "amdgpu-pci-0400":{
      "Adapter": "PCI adapter",
      "vddgfx":{
         "in0_input": 0.650
      },
      "vddnb":{
         "in1_input": 0.655
      },
      "edge":{
         "temp1_input": 41.000
      },
      "slowPPT":{
         "power1_average": 2.072,
         "power1_input": 2.040,
         "power1_cap": 15.000
      },
      "fastPPT":{
         "power2_average": 2.072,
         "power2_cap": 15.000
      }
   },
   "steamdeck_hwmon-isa-0000":{
      "Adapter": "ISA adapter",
      "PD Contract Voltage":{
         "in0_input": 5.000
      },
      "System Fan":{
         "fan1_input": 1522.000,
         "fan1_fault": 0.000
      },
      "Battery Temp":{
         "temp1_input": 25.000
      },
      "PD Contract Current":{
         "curr1_input": 1.000
      }
   },
   "acpitz-acpi-0":{
      "Adapter": "ACPI interface",
      "temp1":{
         "temp1_input": 42.000,
         "temp1_crit": 105.000
      }
   }
}

Não é possível ter o Elastic Agent rodando comandos arbitrários e processando o que eles retornam, então nós precisaremos de um servidorzinho HTTP que colete e retorne esses dados.

Eu fiz um em Go, acesse GitHub - AndersonQ/steamdeck-sensors-api e instale ou faça sua própria versão dele.

Agora nós podemos configurar o Elastic Agent para coletar os dado dessa API. Para garantir que ele estará sempre rodando, steamdeck-sensors-api tem um instalador que instala e registra ele como um serviço usando systemd.

Agora que temos todos os dados que precisamos, é hora de coletá-los.

Coletando os dados

Instale um Elastic Agent. A System integration é adicionada por padrão em toda policy criada. Crie uma nova policy, eu usarei Steam Deck como o nome da minha, e instale um Elastic Agent no seu Steam Deck

De uma olhada no FAQ pra ver como desativar o modo read only usando sudo steamos-readonly disable. Caso você tenha esquecido a senha do root, crie uma nova senha seguindo esse tutorial.

Agora que temos uma policy e um agent instalado, nós podemos configurar a Custom API integration:
Now we have an agent and a policy, we can add and configure the Custom API integration

Navegue para: Management > Integrations e busque por "custom api":

Adicione a tom API integration na sua policy Steam Deck e configure ela assim:

• "Dataset name": system.gpu
• "Request URL": http://localhost:4242/gpu
• "Request Interval": 30s - você pode escolher o intervalo que preferir. Para começar a ver os dados imediatamente e testar as visualizações eu usei 1s.
• "Request HTTP Method": GET
• "Processors":

- decode_json_fields:
    fields: ["message"]
    target: "system.gpu"
    overwrite_keys: true
    add_error_key: true
    expand_keys: true

O processors é fundamental para formatar o evento que será coletado de forma correta. Sem ele, a resposta do steamdeck-sensors-api apareceria como uma string no campo message.

Agora é só salvar e adicionar a integration na sua Steam Deck policy. Se você já instalou o agent, ele irá atualizar a policy automaticamente. Se você ainda não instalou ele, agora é a hora de instalar.

Verificando os dados coletados

Abra o Discover, selecione a data view metrics-* e filtre por event.dataset :"system.process". Agora escolha os campos process.name, system.process.cpu.total.pct and system.process.memory.size para serem visualizados. Abra um jogo no seu Steam Deck e tente achar o processo do jogo que você abriu.

Para ver os dados sobre a GPU, selecione a data view logs-* e filtre por event.dataset :"system.gpu".

Now we just need to create a dashboard.

Steam Deck dashboard

Here is the dashboard I created:

Astro-Win64-Shi is Astroneer, great game, I totally recommend it.

You can import this dashboard, it's on my github repo. I'll explain how to import it in a bit. But first let's see how to create a dashboard and add it a visualisation to it.

Go to `Dashboards > Create dashboard

• In the query bar, add a filter to display data only from your Steam Deck. Filter by host.hostname : "steamdeck", adjusting the hostname if you've changed it on your device."

• Click on Create visialization

• Select the metrics-* dataview

• search for process.cpu

• drag and drop system.process.cpu.total.pct to the drop area

it'll create a chart like this:

• go to "Breakdown" and choose process.name, and set "Number of values" to 15, then close the panel
• instead of "Bar", choose "Treemap" for the visualization

it should be like that:

• go ahead and click "Save and Return"

Now lets create one for the most played games.

• click on Create Visualization"
• on the search bar add the filter process.working_directory.text :"/home/deck/.local/share/Steam/steamapps/common/*". This query on process.working_directory will limit the process metrics to only the process which working directory is /home/deck/.local/share/Steam/steamapps/common/*. This should be the path for all your installed games. Depending on your setup, if you have an SD card, it might change. So if this does not work for you, try checking the process metrics, find the one for your games and see which working_directory they're using.
• drag and drop process.name to the drop area
• select "Tag cloud" for the visualization" type
• click on "Top 5 values of process.name" and set the "Number of Values" to 15
• close the panel
• click on "Save and Return"

It should be like that before you click on "Save and Return"

The dashboard will look like:

To build visualisations with the GPU data, select the logs-* data view and filter for event.dataset : "system.gpu", like that:

I'll leave the creation of the other visualizations as an exercise for you.

Importing and exporting dashboards

You can import the dashboards with the /api/kibana/dashboards/import Kibana Dashboard API

curl -u USER:PASSWORD -H 'Content-Type: application/json' -H 'kbn-xsrf: true' -X POST https://YOUR-KIBANA-HOST/api/kibana/dashboards/import\?exclude\=index-pattern -d "@stead-deck-dashboard.ndjson"

Get the dashboard to import here.

To export a dashboard, use

curl -u USER:PASSWORD -H 'Content-Type: application/json' -H 'kbn-xsrf: true' https://YOUR-KIBANA-HOST/api/kibana/dashboards/export\?dashboard=bfcd09b3-effe-4a65-b58b-b6c3d528cc3e > steam-deck-dashboard.ndjson

To find the dashboard ID, open the dashboard, check the URL, it'll be something like that:

https://KIBANA-HOST/app/dashboards#/view/<dashboard-id>?

https://KIBANA-HOST/app/dashboards#/view/bfcd09b3-effe-4a65-b58b-b6c3d528cc3e?

Conclusion

It's great fun to use the Elastic Stack to monitor my Steam Deck, gaining insights into its performance, how games utilize resources, and identifying running programs and game binaries.

Most importantly, it's a fun way to get started with the Elastic Agent, ingesting monitoring data, and creating visualizations and dashboards. It also provides a glimpse into the vast amount of data we can collect, inspiring different ways to use it.

You can grab a free trial on Elastic Cloud or easily run your own Elastic Stack on Docker or download and run it manually.

1 post - 1 participant

Read full topic