This post is also available in English.
Que tal usar Observability para algo diferente? Nesse post nós usaremos nossas ferramentas favoritas para monitorar como nossos jogos estão performando. Hoje nós exploraremos como usar o Elastic Agent para monitorar um Steam Deck, o que nos permitirá ver o que jogamos mais, o quanto de recurso cada jogo usa e como a GPU está performando.
Nós iremos abordar 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.
Dados sobre a GPU
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. Então nós mesmos iremos disponibilizar esses dados para serem coletados.
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. Então usaremos a versão em JSON, basta rodar sensors -j e o output será em JSON:
{
"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
}
}
}
Como não é possível ter o Elastic Agent rodando comandos arbitrários e processando o que eles retornam, nós precisaremos de um pequeno servidor HTTP que colete e disponibilize 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 nesse 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:
Navegue para: Management > Integrations e busque por "custom api":
Adicione a Custom 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 usei1s. - "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 do evento coletado.
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".
Agora é só criar um dashboard.
Steam Deck dashboard
Esse é o dashboard que eu criei:
Astro-Win64-Shi é Astroneer, ótimo jogo, recomendo.
Você pode importar esse dashboard, ele está no meu github repo. No final eu explico como importar e exportar dashboards. Mas agora vamos criar um e adicionar uma visualização nele.
Navegue para `Dashboards > Create dashboard
- Na barra de pesquisa adicione um filtro prara mosrtar dados apenas do seu Steam Deck. Filtre por
host.hostname : "steamdeck". Ajuste ohostnamese você tiver mudado ele no seu Steam Deck. - Clique em
Create visialization - Selecione a
metrics-*dataview - procure por
process.cpu - selecione e arraste
system.process.cpu.total.pctpara a "drop area"
isso irá gerar um gráfico como este:
- em "Breakdown" selecione
process.name, e então escolha 15 para "Number of values" e finalmente feche o painel. - escolha "Treemap" em vez de "Bar" para a visualização
deverá ficar assim:
- agora clique em "Save and Return"
Agora vamos criar uma visualização para os jogos mais jogados.
- clique em "Create Visualization"
- adicione o filtro
process.working_directory.text :"/home/deck/.local/share/Steam/steamapps/common/*"na barra de busca. Essa query porprocess.working_directorylimitará as métricas sobre processos, selecionando apenas os processos que tem/home/deck/.local/share/Steam/steamapps/common/*como working directory. Esse deve ser o caminho para todos os jogos instalados. Dependendo de como você configurou o seu Steam Deck ou se você tem um cartão SD isso pode mudar. Então se não funcionar pra você, verifique as métricas de processo, procure um dos seus jogos e veja o working directory que ele usa. - selecione e arraste
process.namepara a "drop area" - escolha "Tag cloud" como o tipo de visualização
- clique em "Top 5 values of process.name" e use 15 para "Number of Values"
- feche o painel
- clique em "Save and Return"
Deve estar assim antes de você clicar em "Save and Return"
O dashboard será parecido com esse:
Para fazer a visualização com os dados da GPU escolha a logs-* data view e filtre por event.dataset : "system.gpu", assim:
Eu deixarei como exercício para você cirar essa visualização 
Importar e exportar dashboards
Para importar dashboards use a Kibana Saved Objects API.
curl -u USER:PASSWORD -X POST -H 'Content-Type: multipart/form-data' -H 'kbn-xsrf: true' YOUR-KIBANA-HOST/api/saved_objects/_import\?createNewCopies\=true --form file=@steam-deck-dashboard.ndjson
Download o dashboard que eu criei aqui.
Para exportar um dashboarde, use
curl -u USER:PASSWORD -X POST -H 'Content-Type: application/json' -H 'kbn-xsrf: true' YOUR-KIBANA-HOST/api/saved_objects/_export \
-H "Content-Type: application/json; Elastic-Api-Version=2023-10-31" \
-H "kbn-xsrf: string" \
-d '{"objects":[{"id":"YOUR-DASHBOARD-ID","type":"dashboard"}],"excludeExportDetails":true,"includeReferencesDeep":true}' > steam-deck-dashboard.ndjson
Para achar o ID do dashboard, abra o dashboard, olhe a URL, será algo como:
https://KIBANA-HOST/app/dashboards#/view/<dashboard-id>?
https://KIBANA-HOST/app/dashboards#/view/bfcd09b3-effe-4a65-b58b-b6c3d528cc3e?
Conclusão
É bem legal usar a Elastic Stack para monitorar meu Steam Deck, conseguindo insights sobre sua performance, os recursos que os jogos usam, identificar os programas que estão rodado e o nome do binário de cada um deles.
Mais importante ainda, essa é uma forma divertida de começar a usar o Elastic Agent, coletar dados de monitoramento, criar visualizações e dashboards. Isso também nos dá uma ideia da vasta quantidade de dados que podemos coletar e nos inspira a usá-los de diferente formas.
Tem um free trial na Elastic Cloud ou você pode rodar a sua Elastic Stack com Docker ou baixar e rodar você mesmo.
Agora você já sabe como o seu Steam Deck e rodar uma Elastic Stack, que tal fazer você mesmo?