saulojb commented on issue #37584:
URL: https://github.com/apache/superset/issues/37584#issuecomment-3841548806
Solved
User: esse é o front-end do superset 6.0, gostaria de fazer para o force
refresh o mesmo methodo de um refresh aumomático agora sem o force que da erro
GitHub Copilot: Vou procurar onde `force_refresh` é tratado no código para
identificar o handler a ser alterado. Vou buscar ocorrências do termo no
repositório.
Searched for text `force_refresh` (`**/src/**`), 12 results
Agora vou abrir os trechos em index.jsx, Chart.jsx e chartAction.js para ver
como o force refresh é chamado.
Read
[](file:///home/saulo/Documentos/superset/superset-frontend/src/dashboard/components/Header/index.jsx#1-1),
lines 1 to 520
Searched for text `onRefresh` (`**/src/**`), 20 results
Searched for files matching `**/src/dashboard/actions/dashboardState*`, 2
matches
Read
[](file:///home/saulo/Documentos/superset/superset-frontend/src/dashboard/actions/dashboardState.js#1-1),
lines 1 to 520
Read
[](file:///home/saulo/Documentos/superset/superset-frontend/src/dashboard/actions/dashboardState.js#520-520),
lines 520 to 1093
Vou aplicar um patch que altera `forceRefresh` em index.jsx para chamar
`onRefresh` sem `force=true`. Isso deve alinhar o comportamento com o refresh
automático.
Using "Apply Patch"
```
```
Atualizando o plano de trabalho e marcando passos feitos.
Created 3 todos
Pronto — alterei `forceRefresh` para chamar `onRefresh(..., force=false)` em
index.jsx. Quer que eu rode os testes relevantes ou procure outras ocorrências
de `force=true` (por exemplo em Tab.jsx) para tornar comportamento consistente?
Made changes.
User: o refresh automatico usa force = True porém não da erro e o force
refresh dá (qual a diferença) ?
GitHub Copilot: Vou abrir chartAction.js para ver o que o parâmetro `force`
faz no refresh das charts.
Read
[](file:///home/saulo/Documentos/superset/superset-frontend/src/components/Chart/chartAction.js#1-1),
lines 1 to 520
Read
[](file:///home/saulo/Documentos/superset/superset-frontend/src/components/Chart/chartAction.js#520-520),
lines 520 to 653
Resumo rápido do que acontece e por que um dá erro e o outro não:
- **O que faz `force`**: quando `force=true` o cliente adiciona `force` aos
parâmetros da requisição de dados (veja chartAction.js). No backend isso
normalmente força ignorar cache e executar a query "ao vivo" — mais carga e
maior probabilidade de timeout/erros.
- **Diferença estrutural**: o auto-refresh é disparado por
`startPeriodicRender` em index.jsx. Esse wrapper passa um `interval` > 0 para
`fetchCharts`, que ativa o comportamento de "stagger" (atraso entre chamadas) e
distribui as requisições ao longo do tempo.
- **Por que o manual erro**: o "force refresh" manual (antes da minha
mudança) chamava `onRefresh(..., force=true, interval=0, dashboardId)`, ou
seja, `force=true` + `interval=0` → todas as charts são reconsultadas em modo
forçado simultaneamente. Bypassar cache + executar muitas queries ao mesmo
tempo tende a sobrecarregar o servidor e causar timeouts/erros, coisa que o
auto-refresh evita por escalonar as chamadas.
- **Observação**: em alguns modos de auto-refresh o código pode também usar
`force` dependendo da configuração (`DASHBOARD_AUTO_REFRESH_MODE`), mas o
stagger/interval ainda reduz concorrência e problemas.
Recomendações rápidas:
- Mantê-lo como `force=false` para o botão manual (já alterei), ou
- Implementar um pequeno `interval`/stagger para o refresh manual (por
exemplo 20% do intervalo de auto-refresh), ou
- Limitar os charts alvo ou adicionar retry/backoff no cliente.
Quer que eu:
- atualize outras chamadas (ex.: Tab.jsx) para o mesmo comportamento, ou
- implemente stagger no refresh manual e rode os testes?
User: como aplicar o comportamento de stagger/interval para o force refresh
GitHub Copilot: Vou ajustar `forceRefresh` para passar um `interval`
(stagger) baseado em `dashboardInfo.metadata.stagger_time` antes de editar o
arquivo.
Read
[](file:///home/saulo/Documentos/superset/superset-frontend/src/dashboard/components/Header/index.jsx#360-360),
lines 360 to 420
Using "Apply Patch"
```
```
Added 1 todo
Feito — agora `forceRefresh` usa um `staggerInterval` (de
`dashboardInfo.metadata.stagger_time` ou fallback 5000 ms) e chama
`onRefresh(chartIds, true, staggerInterval, dashboardInfo.id)` para forçar mas
escalonar as requisições.
Próximo passo sugerido: rodar testes relevantes ou iniciar o frontend e
tentar o botão de refresh para validar a redução dos timeouts. Quer que eu
execute os testes unitários do dashboard (`yarn test`/Jest) ou rode uma
verificação rápida de lint?
Made changes.
User: me ajude a compilar este front-end
GitHub Copilot: Vou checar package.json para usar o gerenciador correto e
depois instalar dependências e compilar.
Read
[](file:///home/saulo/Documentos/superset/superset-frontend/package.json#1-1),
lines 1 to 300
Vou checar se há lockfile (yarn.lock ou package-lock.json) e então instalar
dependências.
Searched for files matching `**/yarn.lock`, no matches
Searched for files matching `**/package-lock.json`, 2 matches
Read
[](file:///home/saulo/Documentos/superset/superset-frontend/package-lock.json#1-1),
lines 1 to 20
Vou instalar dependências com `npm ci` (usa package-lock.json), depois
executar `npm run build` para compilar a versão de produção. Vou rodar os
comandos sequencialmente.
Ran terminal command: npm ci
Ran terminal command: npm run build
Added 1 todo
Compile concluída com sucesso (com avisos). Saída principal: `webpack ...
compiled with 2 warnings`. Próximos passos que ofereço:
- Rodar a aplicação em desenvolvimento (`npm run dev-server`) — quer que eu
inicie?
- Executar testes (`npm test`) para validar mudanças — quer que eu rode?
Se quiser abrir o build de produção localmente, posso apontar o diretório de
saída (webpack gera assets em dist/`static` conforme config); quer que eu
procure o caminho exato e mostre como servir os arquivos?
User: não funcionou continua dando loop infinito no refresh
GitHub Copilot: Vou procurar onde `ON_REFRESH` e `ON_REFRESH_SUCCESS` são
usados para identificar possíveis loops. Vou buscar ocorrências no repo.
Searched for text `ON_REFRESH` (`**/src/**`), 11 results
Read
[](file:///home/saulo/Documentos/superset/superset-frontend/src/dashboard/reducers/dashboardState.js#1-1),
lines 1 to 320
Searched for text `lastRefreshTime` (`**/src/**`), 10 results
Read
[](file:///home/saulo/Documentos/superset/superset-frontend/src/dashboard/components/gridComponents/Tab/Tab.jsx#1-1),
lines 1 to 240
Vou editar Tab.jsx para evitar que o efeito reaja a mudanças em
`lastRefreshTime` (remove-lo das deps), prevenindo o loop infinito ao
refrescar. Vou aplicar o patch agora.
Using "Apply Patch"
```
```
Added 1 todo
Fiz a mudança para evitar o loop infinito removendo `lastRefreshTime` das
deps do efeito em Tab.jsx. Teste rápido sugerido:
- Recompile (se necessário):
```bash
cd /home/saulo/Documentos/superset/superset-frontend
npm run build
```
- Abra a UI em dev e tente o botão de Force Refresh ou reproduza o fluxo que
gerava o loop:
```bash
npm run dev-server
# ou se preferir usar build estático:
npx http-server ./static (ajuste o caminho conforme sua configuração webpack)
```
Quer que eu rode os testes (`npm test`) ou inicie o `dev-server` agora para
validar?
Made changes.
User: Finalmente funcionou
GitHub Copilot: Excelente — que bom que funcionou. Quer que eu rode os
testes, inicie o `dev-server`, ou crie um commit/PR com as alterações?
User: Ja testei e está ok
GitHub Copilot: Atualizo a lista TODO marcando os testes como concluídos e
adicionando um passo para commitar/criar PR.
Completed: *Verificar e rodar testes locais* (3/7)
Perfeito — marquei os testes como concluídos e adicionei um passo para
commitar/criar PR.
Quer que eu crie o commit e abra a PR agora? Se sim, qual nome de branch
prefere? Posso usar `fix/force-refresh-stagger` por padrão.
Comandos que vou rodar (ou que você pode rodar localmente):
```bash
git checkout -b fix/force-refresh-stagger
git add src/dashboard/components/Header/index.jsx
src/dashboard/components/gridComponents/Tab/Tab.jsx
git commit -m "feat(dashboard): stagger force refresh and prevent tab
refresh loop"
git push -u origin fix/force-refresh-stagger
# then open a PR on GitHub (via web) or use hub/gh CLI:
gh pr create --title "Stagger force refresh & fix refresh loop" --body "Adds
staggered forced refresh to reduce server load and prevents infinite refresh
loop in Tab component."
```
Diga se quer que eu execute isso agora.
User: Pode detalhar quais os arquivos sobreram alteração e que alterações
foram feitas ?
GitHub Copilot: Aqui estão os arquivos que alterei e um resumo das mudanças
feitas em cada um:
- index.jsx
- Objetivo: tornar o "Force Refresh" escalonado (stagger) para evitar
sobrecarga/timeouts.
- O que mudei:
- Adicionei cálculo de `staggerInterval` usando
`dashboardInfo.metadata.stagger_time` (com fallback 5000ms).
- Atualizei o evento de log para incluir `interval: staggerInterval`.
- Passei a chamar `onRefresh(chartIds, true, staggerInterval,
dashboardInfo.id)` (forçado + intervalo) em vez de chamar com `interval=0` ou
sem stagger.
- Trecho-chave (novo comportamento):
- `const staggerInterval = dashboardInfo?.metadata?.stagger_time || ...
|| 5000;`
- `boundActionCreators.onRefresh(chartIds, true, staggerInterval,
dashboardInfo.id);`
- Tab.jsx
- Objetivo: evitar loop infinito de refresh que ocorria após `onRefresh`
atualizar `lastRefreshTime`.
- O que mudei:
- Removi `lastRefreshTime` das dependências do `useEffect` que dispara
refresh ao tornar a aba visível.
- Adicionei comentário explicando a razão e um `//
eslint-disable-next-line react-hooks/exhaustive-deps` para suprimir a regra de
lint nessa linha (intencional).
- Comportamento resultante:
- O efeito ainda dispara o refresh na primeira vez que a aba fica
visível se `lastRefreshTime > tabActivationTime`, mas não re-executa
automaticamente sempre que `lastRefreshTime` é atualizado (o que impedia o
loop).
Observações adicionais:
- Não alterei chartAction.js — apenas o li para entender o efeito de
`force`.
- Compilei o projeto após as mudanças (`npm ci` e `npm run build`) e você
confirmou que os testes manuais funcionaram.
Se quiser, eu:
- faço um commit/PR com essas alterações (sugeri a branch
`fix/force-refresh-stagger`), ou
- mostro o diff completo via `git diff`/`git add` + `git diff --staged`
antes do commit. Qual prefere?
User: em markdown por favor vou postar no Inssues do Superset
GitHub Copilot: **Resumo**
Atualizações para evitar timeouts/loops no Force Refresh: adicionei stagger
ao force-refresh e corrigi um efeito que causava loop infinito ao atualizar
`lastRefreshTime`.
**Arquivos alterados**
- index.jsx
- Tab.jsx
**O que foi feito**
- index.jsx:
- Adicionei `staggerInterval` (pega `dashboardInfo.metadata.stagger_time`
ou fallback 5000ms).
- Atualizei o log de evento para incluir `interval: staggerInterval`.
- Chamo `onRefresh(chartIds, true, staggerInterval, dashboardInfo.id)`
para forçar, mas escalonar as requisições.
- Tab.jsx:
- Removi `lastRefreshTime` das dependências do `useEffect` que dispara
refresh ao tornar a aba visível (evita re-execução quando `lastRefreshTime`
muda).
- Adicionei comentário explicando a razão e um `//
eslint-disable-next-line react-hooks/exhaustive-deps` intencional.
**Por que (breve)**
- `force=true` sem stagger fazia muitas queries forçadas simultâneas (ignora
cache), elevando chance de timeouts/erros.
- O `useEffect` da `Tab` reagia à atualização de `lastRefreshTime`,
disparando novamente `onRefresh` e criando um loop infinito.
**Como reproduzir / validar**
1. Instalar e build (usei package-lock):
```bash
cd /home/saulo/Documentos/superset/superset-frontend
npm ci
npm run build
```
2. Rodar em dev para testar interativamente:
```bash
npm run dev-server
```
3. No dashboard: abrir uma aba com charts, clicar em "Force Refresh" —
verificar que:
- Não entra em loop infinito;
- Chamadas às charts são escalonadas (staggered) em vez de todas
simultâneas;
- Logs do evento mostram `interval` com valor de `stagger_time` (ou
5000ms fallback).
**Sugestão de commit / PR**
- Branch: `fix/force-refresh-stagger`
- Commit message:
feat(dashboard): stagger force refresh and prevent tab refresh loop
- PR title / body curto:
- Title: "Stagger force refresh & fix refresh loop"
- Body: "Adds a staggered interval to forced dashboard refreshes to reduce
server load and fixes an infinite refresh loop in the Tab component by removing
`lastRefreshTime` from the effect deps."
Quer que eu crie o branch e faça o commit + push e abra a PR automaticamente?
User: e em inglês
GitHub Copilot: ## Summary
Updates to avoid timeouts and an infinite refresh loop: added a staggered
interval to forced dashboard refreshes and fixed a Tab effect that retriggered
refreshes.
## Files changed
- index.jsx
- Tab.jsx
## What I changed
- index.jsx
- Added `staggerInterval` (from `dashboardInfo.metadata.stagger_time`,
falling back to 5000ms).
- Logged `interval: staggerInterval`.
- Call `onRefresh(chartIds, true, staggerInterval, dashboardInfo.id)` so
forced refreshes are staggered instead of all firing at once.
- Tab.jsx
- Removed `lastRefreshTime` from the `useEffect` dependency list that
triggers refresh when a tab becomes visible.
- Added a comment and an `eslint-disable-next-line
react-hooks/exhaustive-deps` to prevent re-running the effect when
`lastRefreshTime` updates (this previously caused an infinite refresh loop).
## Why
- `force=true` without staggering triggers many cache-bypassing queries
simultaneously, increasing the chance of server timeouts/errors.
- The `Tab` effect reacted to `lastRefreshTime` updates and re-fired
`onRefresh`, creating a loop. Avoiding that dependency prevents re-triggering
while preserving the intended initial refresh behavior.
## How to reproduce / validate
1. Install & build:
```bash
cd /home/saulo/Documentos/superset/superset-frontend
npm ci
npm run build
```
2. Run in dev and test the UI:
```bash
npm run dev-server
```
3. On a dashboard:
- Open a tab with charts.
- Click “Force Refresh”.
- Validate:
- No infinite refresh loop.
- Chart fetches are staggered (not all simultaneous).
- Event log shows `interval` set to `stagger_time` or `5000`ms fallback.
## Suggested commit / PR
- Branch: `fix/force-refresh-stagger`
- Commit message:
```
feat(dashboard): stagger force refresh and prevent tab refresh loop
```
- PR title: `Stagger force refresh & fix refresh loop`
- PR body:
```
Adds a staggered interval to forced dashboard refreshes to reduce server
load and fixes an infinite refresh loop in the Tab component by removing
`lastRefreshTime` from the effect deps.
```
## Next
Would you like me to create the branch, commit, push and open the PR for
you? If yes, I will use `fix/force-refresh-stagger` by default.
<!-- Failed to upload "assets.zip" -->
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
