Partilhar via


series_rate_fl()

Aplica-se a: ✅Microsoft FabricAzure Data Explorer✅Azure MonitorMicrosoft Sentinel

A função series_rate_fl() é uma função definida pelo usuário (UDF) que calcula a taxa média de aumento de métrica por segundo. Sua lógica segue a função PromQL rate(). Ele deve ser usado para séries temporais de métricas de contador ingeridas em seu banco de dados pelo sistema de monitoramento Prometheus e recuperadas por series_metric_fl().

Sintaxe

T | invoke series_rate_fl([ n_bins [, fix_reset ]])

Té uma tabela retornada de series_metric_fl(). Seu esquema inclui (timestamp:dynamic, name:string, labels:string, value:dynamic).

Saiba mais sobre as convenções de sintaxe.

Parâmetros

Nome Digitar Obrigatória Descrição
n_bins int O número de compartimentos para especificar a lacuna entre os valores de métrica extraídos para o cálculo da taxa. A função calcula a diferença entre a amostra atual e a n_bins anterior e a divide pela diferença de seus respectivos carimbos de data/hora em segundos. O padrão é um compartimento. As configurações padrão calculam irate(), a função de taxa instantânea PromQL.
fix_reset bool Controla se deve verificar se há redefinições de contador e corrigi-las como a função PromQL rate(). O padrão é true. Defina-o como false para salvar a análise redundante, caso não seja necessário verificar se há redefinições.

Definição de função

Você pode definir a função inserindo seu código como uma função definida por consulta ou criando-a como uma função armazenada em seu banco de dados, da seguinte maneira:

Defina a função usando a instrução let a seguir. Nenhuma permissão é necessária.

Importante

Uma instrução let não pode ser executada sozinha. Ele deve ser seguido por uma instrução de expressão tabular. Para executar um exemplo funcional de series_rate_fl(), consulte Exemplos.

let series_rate_fl=(tbl:(timestamp:dynamic, value:dynamic), n_bins:int=1, fix_reset:bool=true)
{
    tbl
    | where fix_reset                                                   //  Prometheus counters can only go up
    | mv-apply value to typeof(double) on   
    ( extend correction = iff(value < prev(value), prev(value), 0.0)    // if the value decreases we assume it was reset to 0, so add last value
    | extend cum_correction = row_cumsum(correction)
    | extend corrected_value = value + cum_correction
    | summarize value = make_list(corrected_value))
    | union (tbl | where not(fix_reset))
    | extend timestampS = array_shift_right(timestamp, n_bins), valueS = array_shift_right(value, n_bins)
    | extend dt = series_subtract(timestamp, timestampS)
    | extend dt = series_divide(dt, 1e7)                              //  converts from ticks to seconds
    | extend dv = series_subtract(value, valueS)
    | extend rate = series_divide(dv, dt)
    | project-away dt, dv, timestampS, value, valueS
};
// Write your query to use the function here.

Exemplos

Os exemplos a seguir usam o operador invoke para executar a função.

Calcular a taxa média de aumento métrico

Para usar uma função definida por consulta, invoque-a após a definição da função inserida.

let series_rate_fl=(tbl:(timestamp:dynamic, value:dynamic), n_bins:int=1, fix_reset:bool=true)
{
    tbl
    | where fix_reset                                                   //  Prometheus counters can only go up
    | mv-apply value to typeof(double) on   
    ( extend correction = iff(value < prev(value), prev(value), 0.0)    // if the value decreases we assume it was reset to 0, so add last value
    | extend cum_correction = row_cumsum(correction)
    | extend corrected_value = value + cum_correction
    | summarize value = make_list(corrected_value))
    | union (tbl | where not(fix_reset))
    | extend timestampS = array_shift_right(timestamp, n_bins), valueS = array_shift_right(value, n_bins)
    | extend dt = series_subtract(timestamp, timestampS)
    | extend dt = series_divide(dt, 1e7)                              //  converts from ticks to seconds
    | extend dv = series_subtract(value, valueS)
    | extend rate = series_divide(dv, dt)
    | project-away dt, dv, timestampS, value, valueS
};
//
demo_prometheus
| invoke series_metric_fl('TimeStamp', 'Name', 'Labels', 'Val', 'writes', offset=now()-datetime(2020-12-08 00:00))
| invoke series_rate_fl(2)
| render timechart with(series=labels)

Saída

Gráfico mostrando a taxa por segundo da métrica de gravação de disco para todos os discos.

Seleciona o disco principal de dois hosts

O exemplo a seguir seleciona o disco principal de dois hosts e pressupõe que a função já esteja instalada. Este exemplo usa sintaxe alternativa de chamada direta, especificando a tabela de entrada como o primeiro parâmetro:

Para usar uma função definida por consulta, invoque-a após a definição da função inserida.

let series_rate_fl=(tbl:(timestamp:dynamic, value:dynamic), n_bins:int=1, fix_reset:bool=true)
{
    tbl
    | where fix_reset                                                   //  Prometheus counters can only go up
    | mv-apply value to typeof(double) on   
    ( extend correction = iff(value < prev(value), prev(value), 0.0)    // if the value decreases we assume it was reset to 0, so add last value
    | extend cum_correction = row_cumsum(correction)
    | extend corrected_value = value + cum_correction
    | summarize value = make_list(corrected_value))
    | union (tbl | where not(fix_reset))
    | extend timestampS = array_shift_right(timestamp, n_bins), valueS = array_shift_right(value, n_bins)
    | extend dt = series_subtract(timestamp, timestampS)
    | extend dt = series_divide(dt, 1e7)                              //  converts from ticks to seconds
    | extend dv = series_subtract(value, valueS)
    | extend rate = series_divide(dv, dt)
    | project-away dt, dv, timestampS, value, valueS
};
//
series_rate_fl(series_metric_fl(demo_prometheus, 'TimeStamp', 'Name', 'Labels', 'Val', 'writes', '"disk":"sda1"', lookback=2h, offset=now()-datetime(2020-12-08 00:00)), n_bins=10)
| render timechart with(series=labels)

Saída

Gráfico mostrando a taxa por segundo da métrica de gravação do disco principal nas últimas duas horas com 10 compartimentos de intervalo.