# Dez 5, 2024: \[PT\] Monitore seus jogos no Steam Deck com o Elastic Agent

**URL:** <https://discuss.elastic.co/t/dez-5-2024-pt-monitore-seus-jogos-no-steam-deck-com-o-elastic-agent/371224>\
**Category:** Advent Calendar\
**Created:** [December 5, 2024, 8:00am UTC](https://discuss.elastic.co/t/dez-5-2024-pt-monitore-seus-jogos-no-steam-deck-com-o-elastic-agent/371224 "2024-12-05T08:00:51Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![AndersonQ](https://sea2.discourse-cdn.com/elastic/user_avatar/discuss.elastic.co/andersonq/32/112214_2.png) [@AndersonQ](https://discuss.elastic.co/u/AndersonQ)\
**Post date:** [December 5, 2024, 8:00am UTC](https://discuss.elastic.co/t/dez-5-2024-pt-monitore-seus-jogos-no-steam-deck-com-o-elastic-agent/371224/1 "2024-12-05T08:00:51Z")

</div>

This post is also available in [English](https://discuss.elastic.co/t/dec-21st-en-keep-track-of-your-steam-deck-gaming-with-the-elastic-agent/371088).

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](https://www.elastic.co/docs/current/integrations/system) 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](https://www.elastic.co/blog/how-to-monitor-nvidia-gpu-metrics-with-elastic-observability), 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](https://wiki.archlinux.org/title/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:

```auto
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:

```auto
{
   "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](https://github.com/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](https://www.elastic.co/guide/en/fleet/current/install-fleet-managed-elastic-agent.html). 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](https://help.steampowered.com/en/faqs/view/671A-4453-E8D2-323C) 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](https://github.com/AndersonQ/steamdeck-sensors-api).

Agora que temos uma _policy_ e um agent instalado, nós podemos configurar a [Custom API integration](https://www.elastic.co/docs/current/integrations/httpjson):

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

 ![integration-add](https://us1.discourse-cdn.com/elastic/original/3X/6/8/68eca52a054a36572dfcb5ce1bad20157393a35a.png)

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 usei `1s`.
- "Request HTTP Method": `GET`
- "Processors":

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

```

 ![integration-configure-1](https://us1.discourse-cdn.com/elastic/original/3X/9/7/97038eef0f3b9c0b4fd6fd198b3d74b2022648a3.png)  
 ![integration-configure-2](https://us1.discourse-cdn.com/elastic/original/3X/d/5/d5865c2a50ff9505ec6e2829d3c3d733878e17ed.png)

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. 🙂

 ![discover-metrics](https://us1.discourse-cdn.com/elastic/original/3X/6/f/6f4818f7bbc5b7d5f7bba1bbfe3114a72999438e.png)

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

 ![discover-gpu-data](https://us1.discourse-cdn.com/elastic/original/3X/1/8/188eb455e6c70644850329eca458463ecfee1a28.png)

Agora é só criar um dashboard.

## Steam Deck dashboard

Esse é o dashboard que eu criei:

 ![dashboard](https://us1.discourse-cdn.com/elastic/original/3X/3/f/3f785866349642217d5d75fefa9968bc376f131d.png)

`Astro-Win64-Shi` é [Astroneer](https://store.steampowered.com/app/361420/ASTRONEER/), ótimo jogo, recomendo.

Você pode importar esse dashboard, ele está no meu [github repo](https://github.com/AndersonQ/steamdeck-sensors-api/blob/main/steam-deck-dashboard.ndjson). 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 o `hostname` se 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.pct` para a "drop area"

isso irá gerar um gráfico como este:

 ![lens-1](https://us1.discourse-cdn.com/elastic/original/3X/e/b/eb0a63ea6e167dae0185553716ec771817532520.png)

- 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:

 ![lens-2](https://us1.discourse-cdn.com/elastic/original/3X/0/d/0d3d162bd0013815b463f272de981ad894c60b3a.png)

- 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_ por `process.working_directory` limitará 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.name` para 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"

 ![lens-3](https://us1.discourse-cdn.com/elastic/original/3X/f/3/f3905aa00f28a1a8d42d59ca56dd49d772861a4e.png)

O dashboard será parecido com esse:

 ![dashboard-2](https://us1.discourse-cdn.com/elastic/original/3X/e/e/eecd9754d77e8d203b387aa709ec2f6f12f84afb.png)

Para fazer a visualização com os dados da GPU escolha a `logs-*` data view e filtre por `event.dataset : "system.gpu"`, assim:

 ![lens-4](https://us1.discourse-cdn.com/elastic/original/3X/a/e/ae42d6be9402bbf79ceb936fa1417e143e4e1670.png)

Eu deixarei como exercício para você cirar essa visualização 😉

## Importar e exportar dashboards

Para importar dashboards use a [Kibana Saved Objects API](https://www.elastic.co/docs/api/doc/kibana/v8/operation/operation-importsavedobjectsdefault).

```auto
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](https://github.com/AndersonQ/steamdeck-sensors-api/blob/main/steam-deck-dashboard.ndjson).

Para exportar um dashboarde, use

```auto
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:

```auto
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](https://www.elastic.co/cloud/elasticsearch-service/signup) ou você pode rodar a sua [Elastic Stack com Docker](https://www.elastic.co/guide/en/elasticsearch/reference/current/run-elasticsearch-locally.html) ou [baixar](https://www.elastic.co/downloads) e rodar você mesmo.

Agora você já sabe como o seu Steam Deck e rodar uma Elastic Stack, que tal fazer você mesmo?