Pular para o conteúdo

Liberar aos poucos e desligar na hora

Feature Management · Feature flags e experimentação

Flags tipadas no modelo do OpenFeature, com segmentos, rollout por percentual e kill switch; experimentos A/B com análise de significância, também sobre os dados do seu banco; monitor de release e limpeza das flags velhas; e configurações de runtime com JSON Schema, mudança revisada, agendamento e volta em um clique, lidas por um SDK JS/TS que avalia localmente.

O problema

O que este produto resolve

Sem flags, toda mudança visível vai para todos de uma vez, e voltar significa um novo deploy.

Flags feitas em casa costumam virar configuração esquecida, sem tipo, sem dono e sem histórico de quem mudou o quê.

Parâmetros que mudam o comportamento em produção, como o modelo e o prompt de um assistente, acabam em variável de ambiente, fora de qualquer revisão.

atualizado em

Quem usa e para quê

Perfis típicos, sem nomes de clientes. Cada uso leva o status da funcionalidade que o atende.

  • Time de produto de um app de varejoLiberar uma tela nova para um grupo pequeno antes de abrir para todos, e desligar na hora se algo sair errado.Feature flags
  • Time de produtoComparar duas versões de um fluxo de compra com análise estatística, sem declarar vencedor por impressão.Experimentation
  • Time que opera um assistente de IATrocar modelo, temperatura e prompt por ambiente com aprovação de outra pessoa, sem novo deploy.Runtime configuration

Funcionalidades

O que o produto faz

Contratação pela conta, em autoatendimento.

  • Feature flags

    Flags tipadas, segmentos e kill switch compatíveis com OpenFeature.

  • Experimentation

    Testes A/B com análise de significância.

  • Runtime configuration

    Configurações e AI Configs no motor das flags: JSON Schema validado, versões, targeting, mudança com revisão e aprovação, agendamento, volta em um clique e SDK JS/TS com avaliação local.

  • Warehouse experiments

    Análise de experimento com os dados do seu banco: consulta só leitura pelo conector de dados (SELECT validado, tabelas liberadas, auditoria sem os dados) e a mesma estatística dos experimentos.

  • Release monitor and flag cleanup

    Depois de cada mudança de flag, compara o burn rate dos SLOs do serviço na hora antes e na hora depois e sugere o kill switch quando piorou; lista as flags que servem uma variante só (tela, API v1 e recurso MCP flag_cleanup) e abre, para cada uma, um ticket no Code Automation que tira a flag do código com plano aprovado e revisão de outra pessoa.

Como funciona

Do começo ao registro

  1. Flag

    Você cria a flag tipada com as variantes; o código consulta pelo SDK ou por um provedor OpenFeature, sempre com valor padrão.

  2. Público

    Regras por atributo do contexto, segmentos e rollout por percentual, por ambiente. O mesmo contexto cai sempre na mesma variante.

  3. Mudança revisada

    Em ambiente protegido, publicar vira um pedido com nota e diff, aprovado por outra pessoa, aplicado na hora ou na data agendada.

  4. Medida

    O experimento registra exposições e eventos de métrica e compara cada variante com o controle, com análise de significância.

  5. Volta

    O kill switch desliga a flag sem publicar nada; a volta em um clique retorna à versão anterior, com nota e registro. O monitor de release sugere o desligamento quando os SLOs do serviço pioram depois da mudança.

  6. Limpeza

    Flags que servem uma variante só aparecem como candidatas, e cada uma pode virar um ticket no Code Automation que a tira do código, com revisão.

Funcionalidades

Funcionalidade por funcionalidade

O que cada uma faz, como funciona, um exemplo tirado da documentação e o que ela não faz. O selo de cada bloco vem do catálogo.

Feature flags

O código entra desligado e abre por público, com volta imediata.

Feature flags tipadas (booleana, texto, número e JSON) com variantes, regras de público por ambiente, segmentos reutilizáveis e rollout por percentual. Cada avaliação devolve o valor, a variante, o motivo e os metadados, no modelo do OpenFeature, então o seu código fala com um padrão aberto e não com uma API proprietária.

A ordem de avaliação é fixa e previsível: kill switch, flag desligada, regras na ordem em que foram escritas e, por fim, a regra padrão. O kill switch é um estado do ambiente, não da versão: desliga a funcionalidade na hora, sem publicar nada e sem novo deploy.

Como funciona

  • Regras com condições sobre atributos do contexto (igual, diferente, lista, maior e menor, começa com, termina com, contém e comparação de versão semver) e até 5 segmentos por regra.
  • Segmentos com condições e listas de chaves incluídas e excluídas, compartilhados entre flags do workspace.
  • Rollout por percentual com distribuição estável: o balde sai do SHA-256 da chave da flag, do sal e da chave do contexto, em 10.000 baldes. O mesmo contexto cai sempre na mesma variante.
  • Provedores OpenFeature para servidor e navegador no SDK JS/TS, que avalia localmente a partir de um snapshot com o mesmo motor que o servidor usa.
  • Chave do SDK por ambiente, exibida uma única vez; gerar outra revoga a anterior. Toda chamada leva também uma credencial de API com o escopo flags:evaluate.
  • Estado das flags por ambiente em leitura pela API v1 e pelo servidor MCP. Cada versão publicada é imutável e guarda quem publicou; voltar é uma nova publicação.
Com OpenFeature O provedor da AIUBY entra no cliente OpenFeature do servidor; a consulta leva o valor padrão e o contexto. Fora do monorepo, o mesmo cliente é o pacote @aiuby-ia/flags do npm.
import { OpenFeature } from '@openfeature/server-sdk'
import { AiubyFlagsServerProvider, createFlagsClient } from '@aiuby-ia/flags'

await OpenFeature.setProviderAndWait(new AiubyFlagsServerProvider(createFlagsClient({ credential, sdkKey })))
const value = await OpenFeature.getClient().getBooleanValue('checkout-novo', false, { targetingKey: 'cliente-42', plan: 'pro' })

O que não faz

  • Não aceita expressão regular nas regras: use começa com, termina com ou contém.
  • Não envia mudanças por SSE: elas chegam ao SDK por polling com ETag (mínimo de 5 s, padrão de 30 s).
  • O SDK oficial é JS/TS, para navegador e Node 18+. Outras linguagens usam a rota de avaliação remota.
  • A credencial não vai ao navegador: o snapshot traz as listas de chaves dos segmentos, por isso o front-end o recebe por uma rota do seu backend.

Experimentation

Decidir entre variantes com estatística, não com impressão.

Um experimento é uma flag com rollout entre variantes mais duas medidas: a exposição (quem viu qual variante) e os eventos de métrica (o que cada contexto fez depois). O relatório compara cada variante com o controle e só declara diferença quando ela é estatisticamente significativa.

Para conversão, o relatório usa o teste z de duas proporções, com intervalo de Wilson por variante e de Wald para a diferença; para médias, o teste de Welch. Com mais de uma variante contra o controle, entra a correção de Bonferroni, com α = 0,05.

Como funciona

  • A exposição só é aceita com o token assinado que a avaliação do servidor devolve, válido por 24 h. Ninguém registra exposição de uma variante que não recebeu.
  • Eventos de métrica com nome, valor e chave do contexto. A faixa aceita de valor é definida por métrica por quem administra.
  • Pseudônimo no lugar da identidade: o banco guarda só um HMAC da chave do contexto, derivado do segredo do servidor e do sal do ambiente. Quem lê o banco não refaz o hash de um e-mail.
  • Aviso de amostra pequena: com menos de 30 contextos por variante, ou menos de 5 sucessos ou fracassos numa conversão, o relatório não declara nenhuma variante significativa.
  • Sem significância depois da correção, o relatório não aponta vencedor.
  • Exposições e eventos de métrica ficam guardados por 90 dias.
Pela API do SDK Avaliar no servidor, registrar a exposição com o token devolvido, enviar os eventos de métrica e ler o relatório.
POST /api/platform/flags/sdk/evaluate   { context: { key, ... }, flagKey }
POST /api/platform/flags/exposures      { exposures: [{ token, occurredAt? }] }   token = flagMetadata.exposureToken
POST /api/platform/flags/metrics        { events: [{ name, value = 1, contextKey, occurredAt? }] }
GET  /api/platform/flags/experiments/{flag}/report

O que não faz

  • O relatório considera só as exposições e os eventos de métrica enviados à plataforma; para medir com os dados do seu banco, a análise no warehouse usa a mesma estatística.
  • A avaliação local do SDK não gera o token de exposição; experimento com exposição gravada usa a avaliação remota.
  • O relatório é só para quem administra o workspace, e a ordem entre exposição e evento é a de recebimento no servidor.
  • Trocar o segredo do servidor muda os pseudônimos: os experimentos em andamento recomeçam do zero.

Runtime configuration

Mudar o comportamento da aplicação sem deploy e com revisão.

Uma configuração de runtime é uma flag do tipo JSON com um JSON Schema: o mesmo motor das feature flags, com versões imutáveis, regras de público por ambiente e segmento, kill switch e chaves do SDK. Cada variante de cada versão é validada contra o schema antes de gravar, então um valor malformado não chega à aplicação.

O preset de AI Config traz um schema pronto para parâmetros de IA (modelo, temperatura, topP, limite de tokens de saída, prompt da biblioteca do workspace, paradas e limites). A sua aplicação lê a configuração pelo SDK e aplica; a AIUBY não chama modelo com ela.

Como funciona

  • Ambiente protegido: a publicação direta responde 409 e a mudança vira um pedido com nota obrigatória, que fica pendente até outra pessoa que administra aprovar. O autor não aprova o próprio pedido; o banco também recusa.
  • Diff de revisão entre a versão em vigor e a versão pedida, antes da decisão.
  • Agendamento de até 90 dias: o pedido aprovado é aplicado na data, em nome de quem autorizou por último. Se a versão em vigor mudou desde o pedido, ele falha em vez de aplicar um diff velho.
  • Volta em um clique para a versão que estava em vigor antes da atual, na hora, com nota e registro na auditoria.
  • SDK JS/TS @aiuby-ia/flags com avaliação local: baixa um snapshot, faz polling com ETag (304 sem corpo quando nada mudou) e avalia sem ida à rede. Modos online, com cache e offline.
  • Cada passo da mudança (pedido, aprovação, recusa, cancelamento, aplicação, falha e volta) é registrado na auditoria, e aplicar passa pela política flag.publish.
Mudança com revisão Proteger o ambiente, ver o diff, pedir a mudança (agora ou agendada), decidir e, se preciso, voltar. A aplicação lê com client.getJson('assistente.config', ctx, padrao).
PATCH /api/platform/flags/environments/{env}        { requiresApproval }
GET   /api/platform/flags/flags/{key}/review?environment=&to=&from=
POST  /api/platform/flags/flags/{key}/changes       { environment, version, note, scheduledFor? }
POST  /api/platform/flags/changes/{id}              { action: approve | reject | cancel, note? }
POST  /api/platform/flags/flags/{key}/rollback      { environment, note }

O que não faz

  • O JSON Schema aceito é um subconjunto: pattern, format, $ref, oneOf, anyOf, allOf, not, if e patternProperties são recusados com mensagem. Limites: schema de 16 KB, 8 níveis e 100 propriedades por objeto; valor de cada variante até 8 KB.
  • Schema e preset são fixos depois de criados. Para mudar o formato, crie outra chave.
  • A AIUBY não chama modelo com a AI Config nem aplica os limites dela: quem aplica é a sua aplicação.
  • Não há SSE: a mudança chega por polling. Cada flag e ambiente aceita um pedido aberto por vez.

Warehouse experiments

Experimentos medidos com os números que o seu time confia.

A análise no warehouse usa os dados que estão no seu banco, em vez de pedir que eventos sejam enviados de novo. Você escreve a consulta que conta exposições e conversões (ou soma e variância) por variante, e a plataforma aplica a mesma estatística dos experimentos.

A consulta vai ao banco pelo conector de dados do workspace, o mesmo que serve aos outros produtos: só leitura, só nas tabelas que quem administra liberou e com a conexão protegida. A AIUBY recebe apenas as linhas agregadas por variante.

Como funciona

  • Consulta só leitura pelo conector de dados: um SELECT validado, só nas tabelas liberadas no conector, com até 200 linhas.
  • Conversão (variant, n, conversions) com intervalo de Wilson, ou média (variant, n, mean, variance) com teste de Welch.
  • Correção de Bonferroni com mais de uma variante e aviso de amostra pequena, sem declarar vencedor quando não há diferença significativa.
  • Cada consulta entra na auditoria com o SQL e a contagem de linhas, nunca com os dados.

Exemplo de uso

O time de checkout grava exposição e compra no próprio Postgres de analytics. Em vez de duplicar eventos, a analista escreve a consulta que agrupa por variante e recebe o resultado do teste com o controle, o intervalo de cada variante e o veredito.

O que não faz

  • Funciona com bancos compatíveis com Postgres, pelo conector de dados. Não conecta Snowflake, BigQuery nem Trino.
  • A análise roda sob demanda e não fica salva como relatório recorrente.
  • Não grava nada no banco do cliente e não muda a flag: decidir o rollout é com o time.

Release monitor and flag cleanup

Saber se a mudança piorou o serviço e tirar flags velhas.

Depois de publicar ou desligar uma flag ligada a um serviço, o monitor de release compara o burn rate dos SLOs desse serviço na hora antes e na hora depois da última mudança. Se o depois passou de 1 e ficou pelo menos duas vezes pior que o antes, a tela sugere o kill switch, com os números das duas janelas.

Na outra ponta da vida da flag, a limpeza aponta as que não decidem mais nada: servem a mesma variante em todos os ambientes, estão desligadas em todos ou nunca foram publicadas. Para cada uma, quem administra abre um ticket no Code Automation com o pedido exato de remoção, e a mudança no código segue o fluxo de lá, com plano aprovado, patch testado e revisão de outra pessoa.

Como funciona

  • Monitor por flag: janela de uma hora antes e uma depois da última mudança, sobre as amostras de SLI de cada SLO do serviço; sem amostra, o resultado aparece como sem dado.
  • A sugestão leva à mesma ação de desligar, com política flag.publish e auditoria; a plataforma não desliga a flag sozinha.
  • Regra fixa da limpeza, sem modelo: idade mínima configurável (de 7 a 365 dias, padrão 30), motivo de cada flag, dias desde a última mudança e a última exposição recebida em cada ambiente.
  • A mesma lista na tela, na API v1 (engineering:read) e no recurso MCP flag_cleanup, só leitura, para assistentes e agentes consultarem.
  • Ticket de remoção: tirar as chamadas que avaliam a chave e manter só o caminho da variante que todos recebem; o critério de aceite é nenhuma referência à chave e os testes passando.
Pela API A lista de candidatas, pela sessão e pela chave de API com engineering:read, com o motivo de cada flag.
GET /api/platform/flags/stale?minAgeDays=30
GET /api/v1/engineering/flag-cleanup?minAgeDays=30

O que não faz

  • O monitor só sugere e não manda alerta: alguém precisa abrir a flag para ver a comparação.
  • O monitor depende de a flag estar ligada a um serviço com SLO e amostras de SLI.
  • "Nenhuma exposição no período" não prova que o código parou de avaliar a flag: depende de o SDK enviar e da amostragem.
  • A plataforma não apaga nem arquiva flag e não mescla o PR de remoção: o merge é do seu time.

Governança e segurança

Regras que o código impõe

  • Em ambiente protegido, a mudança só entra com a aprovação de outra pessoa que administra; o autor não aprova o próprio pedido, e o banco também recusa.
  • Versões são imutáveis, e cada variante de uma configuração é validada contra o JSON Schema antes de gravar.
  • Publicar passa pela política flag.publish; pedido, aprovação, recusa, aplicação, falha e volta ficam na auditoria.
  • O kill switch continua direto, para emergência, mesmo em ambiente protegido.
  • A exposição de experimento só é aceita com o token assinado da avaliação, e o banco guarda um pseudônimo no lugar da chave do contexto.
  • A chave do SDK é por ambiente, aparece uma vez só, e gerar outra revoga a anterior; a credencial de servidor não vai ao navegador.
  • Pedido cuja versão em vigor mudou desde a abertura falha em vez de aplicar um diff velho.

Integrações

Com o que se conecta

Só integrações que existem no código. Cada uma leva o status da funcionalidade que a usa.

  • OpenFeatureProvedores para @openfeature/server-sdk e @openfeature/web-sdk: o seu código consulta flags pelo padrão aberto.Feature flags
  • SDK JS/TS @aiuby-ia/flagsCliente sem dependência para navegador e Node 18+, com avaliação local a partir do snapshot, cache e modo offline.Runtime configuration
  • Biblioteca de promptsA AI Config referencia um prompt do workspace e a versão publicada dele.Runtime configuration
  • API v1Leitura das flags e do estado por ambiente com uma chave de escopo.API, CLI & keys
  • Servidor MCPO estado das flags por ambiente e as candidatas à limpeza (recurso flag_cleanup) ficam legíveis para clientes MCP, só leitura.MCP server
  • Conector de dadosA análise no warehouse consulta o seu banco compatível com Postgres, só leitura e só nas tabelas liberadas.Warehouse experiments
  • Code AutomationA remoção de uma flag velha vira um ticket com plano aprovado, patch testado e PR em rascunho revisado por outra pessoa.Release monitor and flag cleanup
  • PolíticasA política flag.publish é avaliada a cada publicação.Governance & policies

Perguntas frequentes

Respostas diretas

O que já dá para usar hoje?

Disponível: Feature flags, Experimentation, Runtime configuration, Warehouse experiments, Release monitor and flag cleanup. Contratação pela conta, em autoatendimento.

Vou precisar trocar o SDK que uso?

Disponível: Feature flags, Runtime configuration. Se o seu código fala OpenFeature, não: o SDK traz provedores para o servidor e para o navegador, e a consulta continua a mesma. O SDK oficial é JS/TS; em outras linguagens, a avaliação é feita pela rota remota.

Uma flag fora do ar derruba a minha aplicação?

Disponível: Feature flags, Runtime configuration. Não. O SDK avalia localmente a partir de um snapshot: falha de rede mantém o último snapshot, o modo com cache funciona sem rede, e sem snapshot toda consulta devolve o valor padrão que o seu código passou. Para o caminho inverso, o kill switch desliga a funcionalidade sem novo deploy.

Quem pode mudar uma flag em produção?

Disponível: Runtime configuration. Quem administra o workspace. Com o ambiente protegido, a publicação direta é recusada e a mudança vira um pedido com nota obrigatória, que só outra pessoa que administra aprova. A volta para a versão anterior não pede segundo aprovador, porque vai para uma versão que esteve no ar; pede nota e é auditada.

Quais testes estatísticos o experimento usa?

Disponível: Experimentation. Para conversão, z de duas proporções com intervalo de Wilson por variante e de Wald para a diferença; para médias, o teste de Welch. Com mais de uma variante contra o controle, entra a correção de Bonferroni, com α = 0,05. Com menos de 30 contextos por variante, ou menos de 5 sucessos ou fracassos numa conversão, o relatório avisa que a amostra é pequena. Sem significância depois da correção, não declara vencedor.

O experimento analisa os dados do meu data warehouse?

Disponível: Warehouse experiments, Experimentation. Pode analisar, se o banco for compatível com Postgres. A análise no warehouse roda a sua consulta só leitura pelo conector de dados, nas tabelas liberadas, e aplica a mesma estatística dos experimentos às linhas agregadas por variante; a auditoria guarda o SQL e a contagem de linhas, nunca os dados. Snowflake, BigQuery e Trino não são conectados. Sem o warehouse, o relatório usa as exposições e os eventos que a sua aplicação envia, guardados por 90 dias e com a chave do contexto trocada por um pseudônimo.

A plataforma desliga uma flag sozinha quando o serviço piora?

Disponível: Release monitor and flag cleanup. Não. O monitor de release compara o burn rate dos SLOs do serviço na hora antes e na hora depois da última mudança da flag e sugere o kill switch quando piorou; desligar continua sendo uma ação de quem administra, com política e auditoria. Do mesmo jeito, a limpeza aponta flags que servem uma variante só e abre um ticket no Code Automation para tirá-las do código, mas nada é apagado nem mesclado pela plataforma.

Quanto custa?

Disponível: Feature flags, Experimentation, Runtime configuration. Não há preço definido. Quando houver, ele aparece na página de Preços.

Funciona junto com

  • AI EngineeringUma AI Config aponta para um prompt da biblioteca de prompts do workspace, e a versão indicada precisa estar publicada lá.
  • Engineering IntelligenceA publicação de uma flag emite o evento flag.rollout.changed, e o estado das flags por ambiente sai em leitura pela API de engenharia.

Feature Management

Contratação pela conta, em autoatendimento.