Usando janelas de eventos
Em aplicativos que processam eventos em tempo real, um requisito comum é executar alguma computação baseada em conjuntos (agregação) ou outras operações em subconjuntos de eventos que estão dentro de um certo período de tempo. No StreamInsight, esses subconjuntos de eventos são definidos por meio de janelas. Este tópico descreve as janelas e como elas são definidas, identifica os tipos de janelas com suporte no StreamInsight e explica como é possível usá-las com vários operadores.
Nesta seção
Tipos de janelas
Operações em janelas
Noções básicas sobre janelas
Uma janela contém dados de eventos ao longo de uma linha do tempo e permite executar várias operações nos eventos dentro dessa janela. Por exemplo, você talvez queira somar os valores dos campos de carga em uma determinada janela conforme mostrado na ilustração a seguir.
.gif "Explica o conceito de uma janela de eventos.")
A ilustração anterior mostra como uma janela de salto se aplica a um fluxo de eventos e como uma agregação se aplica ao fluxo de janelas. A forma dos eventos que possuem os resultados da agregação depende da política de saída da janela; aqui eles são representados por eventos pontuais no final da janela.
A operação em janela transforma o fluxo de eventos em um fluxo de janelas (CepWindowStream<T>), que pode acabar servindo como base para uma operação baseada em conjunto. Cada janela ao longo da linha de tempo representa um conjunto de eventos. O tipo de janela que você usa determina como os eventos são colocados; as janelas podem se basear no tempo ou na contagem. Cada tipo de janela é representado por um operador de janelas.
A operação baseada em conjunto transforma um fluxo de janelas novamente em um fluxo de eventos (CepStream<T>). Essas operações baseadas em conjuntos são divididas nestes dois grupos:
Agregações que geram um resultado escalar para um conjunto de eventos de entrada.
Operações que geram zero ou mais eventos de saída para um conjunto de eventos de entrada.
Exemplos do primeiro grupo são sum, avg, count e agregações definidas pelo usuário. Uma ou mais dessas agregações podem ser aplicadas a um fluxo de janela, de tal forma que um evento de resultado corresponda a cada janela de entrada, com os resultados de agregação escalares como campos na carga do evento resultante. Por exemplo, talvez você queira somar os valores de um ou mais campos de carga em uma janela e, com base nesses valores, executar o processamento adicional ou criar outro fluxo de eventos que contenha esses dados agregados.
Exemplos do segundo grupo são o operador TopK e os operadores definidos pelo usuário. Eles são definidos em um fluxo de janela e geram zero ou vários eventos por janela como resultado da sua computação. Por exemplo, talvez você queira usar o operador TopK para tomar os cinco eventos principais de cada janela de instantâneo definida para um fluxo de entrada específico e gerar um novo fluxo de eventos para processamento adicional.
Quando os eventos de um fluxo em janela são passados para um operador baseado em conjunto, e também quando eles são retirados de um operador baseado em conjunto e devolvidos ao fluxo, seus carimbos de data/hora podem ser transformados. Essas transformações são chamadas de política de entrada e política de saída, respectivamente. Essas políticas afetam a maneira como os eventos são exibidos em janelas e como o resultado da operação baseada em conjunto é transmitido.
O StreamInsight dá suporte aos seguintes tipos de janela:
Especificando janelas
Conforme mostrado na seguinte ilustração, uma especificação de janela é constituída de três partes:
A definição de janela (durações de uma janela de saltos, uma contagem da janela baseada em contagem, sem parâmetro para uma janela de instantâneo)
Uma transformação temporal da entrada (política de entrada)
Uma transformação temporal da saída (política de saída)
.gif "Fluxos de evento nas agregações definidas pelo usuário")
A ilustração descreve de forma conceitual as transformações de um fluxo quando ele passa por uma operação baseada em conjunto sobre uma janela.
No ponto A, um fluxo de eventos é inserido no operador da janela.
No ponto B, o operador da janela gera um fluxo de janelas. Cada janela contém um conjunto de eventos. Os tempos de vida desses eventos podem ter sido alterados de acordo com a Política de entrada. O fluxo de eventos é inserido em um operador baseado em conjunto, como, por exemplo, uma agregação ou um operador definido pelo usuário.
No ponto C, o operador baseado em conjunto processa cada janela e gera um fluxo de eventos como saída.
Para agregações, é criado um evento para cada conjunto (ou nenhum quando a janela está vazia). Como a agregação especifica apenas um valor escalar, o tempo de vida do evento de saída é definido por padrão como o período de tempo da janela. Isso se aplica a agregações internas, assim como ao resultado de agregações definidas pelo usuário.
Para os operadores definidos pelo usuário e o operador TopK, zero ou mais eventos são gerados. UDOs com detecção de hora também especificam os tempos de vida do evento de saída. Para UDOs sem detecção de hora e operadores TopK, o tempo de vida do evento de saída é definido por padrão como o período de tempo da janela.
No ponto D, uma política de saída pode ser se aplicada aos eventos de saída. Isso permite ao autor da consulta modificar as propriedades temporais dos eventos e substituir os valores de tempo de vida padrão gerados pelo operador baseado em conjunto.
Programaticamente, as três caixas brancas da ilustração são manifestadas como parâmetros para os operadores de janela.
Políticas de janela
Operadores de janela criam fluxos de janelas, que são a entrada exigida para qualquer operação baseada em conjunto. Além da definição da própria janela (em termos de hora ou contagem), o autor da consulta pode influenciar como 1) a operação em janela afeta os tempos de vida dos eventos contidos na janela quando eles são passados para a operação baseada em conjunto e 2) como os tempos de vida dos eventos do resultado da operação devem ser ajustados.
Ambas as políticas são especificadas pelo autor da consulta como parte do operador da janela para controlar ou substituir os carimbos de data/hora padrão da agregação ou do UDO na parte superior da janela.
Políticas de entrada
Nesta versão, o StreamInsight dá suporte à política de entrada única de recortar a hora de início e a hora de término dos eventos na janela para a hora de início e a hora de término da janela. Isso significa que qualquer operação baseada em conjunto (detecção de hora) só verá carimbos de data/hora do evento dentro da janela, embora os eventos originais possam ter sido substituídos fora da janela antes da política de entrada ser aplicada.
A especificação da política de entrada é opcional. Por uma questão de praticidade, a classe WindowInputPolicy fornece uma propriedade estática que retorna uma instância correspondente (WindowInputPolicy.ClipToWindow).
Políticas de saída
Nesta versão, o StreamInsight dá suporte às seguintes políticas de saída:
Janelas de instantâneo: as hora de término dos eventos resultantes serão recortadas de acordo com a hora de término da janela.
As janelas de salto oferecem suporte a estas duas políticas de saída:
Os eventos resultantes são eventos pontuais alinhados à hora de término da janela.
As horas de término dos eventos resultantes serão recortadas de acordo com a hora de término da janela.
Janelas de contagem: o evento resultante se transforma em um evento pontual no final da janela.
Para cada tipo de janela, há uma classe de política de saída separada ou existem classes. Por uma questão de praticidade, as classes de política de saída fornecem uma propriedade estática que retorna uma instância correspondente:
SnapshotWindowOutputPolicy.Clip (padrão, caso não seja especificado)
HoppingWindowOutputPolicy.ClipToWindowEnd
HoppingWindowOutputPolicy.PointAlignToWindowEnd (padrão, caso não seja especificado)
CountWindowOutputPolicy.PointAlignToWindowEnd (padrão, caso não seja especificado)
Resumo de todas as janelas disponíveis e seu efeito no resultado da operação baseada em conjunto:
Janela de instantâneo:
Política de saída: sempre “Recortar no final da janela”
Tempos de vida da saída:
ClipToWindowEnd |
|
|---|---|
Agregações internas |
tamanho da janela |
TopK |
tamanho da janela |
UDA sem detecção de hora |
tamanho da janela |
UDO sem detecção de hora |
tamanho da janela |
UDA/UDO sem detecção de hora |
n/a para janelas de instantâneo |
Janela de salto:
Política de saída: “Recortar no final da janela” ou "PointAlignToWindowEnd"
Tempos de vida da saída:
ClipToWindowEnd |
PointAlignToWindowEnd |
|
|---|---|---|
Agregações internas |
tamanho da janela |
ponto no final da janela |
TopK |
tamanho da janela |
ponto no final da janela |
UDA |
tamanho da janela |
ponto no final da janela |
UDO |
tamanho da janela |
Ponto(s) no final da janela |
UDO com detecção de hora |
tempos de vida retornados, recortados no final da janela |
ponto(s) no final da janela |
Janela de contagem:
Política de saída: sempre “Ponto no final da janela”
Tempos de vida da saída:
PointAlignToWindowEnd |
|
|---|---|
Agregações internas |
n/a para janelas de contagem |
TopK |
n/a para janelas de contagem |
UDA |
ponto no final da janela |
UDO |
ponto(s) no final da janela |
UDO com detecção de hora |
ponto(s) no final da janela |