Maneira simples de identificar algoritmos um aumento nos erros registrados

Precisamos de um sistema de alerta precoce. Estou lidando com um servidor conhecido por ter problemas de desempenho sob carga. Os erros são registrados em um banco de dados junto com um carimbo de data e hora. Existem algumas etapas de intervenção manual que podem ser tomadas para diminuir a carga do servidor, mas apenas se alguém estiver ciente do problema ...

Dado um conjunto de horários em que os erros ocorreram, como posso identificar o início de um pico de erros (em tempo real)? Podemos calcular periodicamente ou em cada ocorrência de erro.

Não estamos preocupados com erros ocasionais, mas não temos um limite específico. Eu poderia notificar alguém a qualquer momento, digamos, três erros em cinco minutos, mas tenho certeza de que há uma maneira melhor ...

Eu gostaria de poder ajustar a sensibilidade do algoritmo com base nos comentários dos administradores do sistema. Por enquanto, eles gostariam que fosse bastante sensível, mesmo sabendo que podemos esperar alguns falsos positivos.

Eu não sou um estatístico, o que, com certeza, é óbvio, e a implementação disso precisa ser relativamente simples com nossas ferramentas existentes: SQL Server e ASP JScript da velha escola. Não estou procurando uma resposta no código, mas se precisar de um software adicional, provavelmente não funcionará para nós (embora seja um comentário para soluções impraticáveis, mas ideais, para minha própria curiosidade).

Já se passaram 5 meses desde que você fez essa pergunta e, esperançosamente, descobriu alguma coisa. Vou fazer algumas sugestões diferentes aqui, esperando que você encontre alguma utilidade para elas em outros cenários.

Para o seu caso de uso, acho que você não precisa procurar algoritmos de detecção de pico.

Então, aqui vai: Vamos começar com uma imagem dos erros que ocorrem em uma linha do tempo:

O que você deseja é um indicador numérico, uma "medida" da rapidez com que os erros estão chegando. E essa medida deve ser passível de limiar - seus administradores de sistema devem poder definir limites que controlam com que erros de sensibilidade se transformam em avisos.

Medida 1

Você mencionou "picos", a maneira mais fácil de obter um pico é desenhar um histograma a cada intervalo de 20 minutos:

Seus administradores de sistema definiriam a sensibilidade com base nas alturas das barras, ou seja, os erros mais toleráveis ​​em um intervalo de 20 minutos.

(Nesse ponto, você deve estar se perguntando se esse tamanho de janela de 20 minutos não pode ser ajustado. Pode, e você pode pensar no tamanho da janela como definindo a palavra juntos nos erros de frase que aparecem juntos .)

Qual é o problema com esse método para o seu cenário específico? Bem, sua variável é um número inteiro, provavelmente menor que 3. Você não definiria seu limite como 1, pois isso significa apenas "todo erro é um aviso" que não requer um algoritmo. Portanto, suas escolhas para o limite serão 2 e 3. Isso não dá a seus administradores de sistema muito controle refinado.

Medida 2

Em vez de contar erros em uma janela de tempo, acompanhe o número de minutos entre o erro atual e o último. Quando esse valor fica muito pequeno, significa que seus erros estão ficando muito frequentes e você precisa emitir um aviso.

Seus administradores de sistema provavelmente definirão o limite em 10 (ou seja, se ocorrerem erros com menos de 10 minutos de diferença, é um problema) ou 20 minutos. Talvez 30 minutos para um sistema menos crítico.

Essa medida fornece mais flexibilidade. Ao contrário da Medida 1, para a qual havia um pequeno conjunto de valores com os quais você poderia trabalhar, agora você tem uma medida que fornece bons valores de 20 a 30. Seus administradores de sistema terão, portanto, mais possibilidades de ajuste fino.

Conselho Amigável

Há outra maneira de abordar esse problema. Em vez de observar as frequências de erro, pode ser possível prever os erros antes que eles ocorram.

Você mencionou que esse comportamento estava ocorrendo em um único servidor, que é conhecido por ter problemas de desempenho. Você pode monitorar certos indicadores-chave de desempenho nessa máquina e pedir que eles avisem quando um erro ocorrerá. Especificamente, você examinaria o uso da CPU, o uso da memória e os KPIs relacionados à E / S de disco. Se o uso da CPU ultrapassar 80%, o sistema ficará mais lento.

(Eu sei que você disse que não queria instalar nenhum software, e é verdade que você pode fazer isso usando o PerfMon. Mas existem ferramentas gratuitas por aí que farão isso por você, como Nagios e Zenoss .)

E para as pessoas que vieram aqui na esperança de encontrar algo sobre a detecção de picos em uma série temporal:

Detecção de pico em uma série temporal

A coisa mais simples que você deve começar é calcular uma média móvel dos seus valores de entrada. Se sua série é , você calcula uma média móvel após cada observação como:$x_1, x_2,...$

$M_k = (1 - \alpha) M_{k-1} + \alpha x_k$

onde o determinaria quanto peso forneceria o valor mais recente de .$\alpha$$x_k$

Se seu novo valor se afastou muito da média móvel, por exemplo

$\frac{x_k - M_k}{M_k} > 20\%$

então você levanta um aviso.

As médias móveis são boas quando se trabalha com dados em tempo real. Mas suponha que você já tenha um monte de dados em uma tabela e só queira executar consultas SQL para encontrar os picos.

Eu sugeriria:

1. Calcule o valor médio de suas séries temporais
2. Calcular o desvio padrão $\sigma$
3. Isole os valores acima de acima da média (pode ser necessário ajustar o fator "2")$2\sigma$

Mais coisas divertidas sobre séries temporais

1. Muitas séries temporais do mundo real exibem comportamento cíclico. Existe um modelo chamado ARIMA que ajuda a extrair esses ciclos de suas séries temporais.

2. Médias móveis que levam em consideração o comportamento cíclico: Holt e Winters

+1 para controle estatístico de processos, há algumas informações úteis aqui na Detecção de etapas .

Para o SPC, não é muito difícil escrever uma implementação das Regras da Western Electric ou das Regras de Nelson .

Basta criar um USP no servidor SQL que irá percorrer um conjunto de dados e executar ping em cada ponto nas regras usando seus pontos vizinhos. Talvez resuma o número de erros por hora (dependendo das suas necessidades).

Isso está relacionado a uma pergunta que eu postei no Stack Overflow há algum tempo (acabei de escrever uma resposta rápida, se isso ajudar): Gráficos de controle estatístico de processos no SQL Server 2008 R2

Uma pesquisa por algoritmos de detecção on - line seria um começo.

Mais informações localizadas no stackoverflow: Detecção de pico do sinal medido

Uma implementação python de uma rotina ingênua de detecção de pico pode ser encontrada no github

Você pode querer examinar o controle estatístico do processo. Ou monitoramento de séries temporais. Há muito trabalho nessa direção, e a resposta ideal provavelmente depende muito do que exatamente você está fazendo (você precisa filtrar sazonalidades anuais ou semanais na carga antes de detectar anomalias etc.).