autocannon
v8.0.0
Uma ferramenta de benchmarking HTTP/1.1 escrita no nó, muito inspirada no WRK e WRK2, com suporte para Pipelining HTTP e HTTPS. Na minha caixa, o Autocannon pode produzir mais carga que wrk e wrk2 , consulte Limitações para obter mais detalhes.
Instalação
Uso
API
Agradecimentos
Licença
npm i autocannon -g
Ou se você quiser usar a API ou como dependência:
npm i autocannon --save
Usage: autocannon [opts] URL
URL is any valid HTTP or HTTPS URL.
If the PORT environment variable is set, the URL can be a path. In that case 'http://localhost:$PORT/path' will be used as the URL.
Available options:
-c/--connections NUM
The number of concurrent connections to use. default: 10.
-p/--pipelining NUM
The number of pipelined requests to use. default: 1.
-d/--duration SEC
The number of seconds to run the autocannon. default: 10.
-a/--amount NUM
The number of requests to make before exiting the benchmark. If set, duration is ignored.
-L NUM
The number of milliseconds to elapse between taking samples. This controls the sample interval, & therefore the total number of samples, which affects statistical analyses. default: 1.
-S/--socketPath
A path to a Unix Domain Socket or a Windows Named Pipe. A URL is still required to send the correct Host header and path.
-w/--workers
Number of worker threads to use to fire requests.
-W/--warmup
Use a warm up interval before starting sampling.
This enables startup processes to finish and traffic to normalize before sampling begins
use -c and -d sub args e.g. `--warmup [ -c 1 -d 3 ]`
--on-port
Start the command listed after -- on the command line. When it starts listening on a port,
start sending requests to that port. A URL is still required to send requests to
the correct path. The hostname can be omitted, `localhost` will be used by default.
If the command after -- is `node <script>`, this flag is optional and assumed to be `true`.
-m/--method METHOD
The HTTP method to use. default: 'GET'.
-t/--timeout NUM
The number of seconds before timing out and resetting a connection. default: 10
-T/--title TITLE
The title to place in the results for identification.
-b/--body BODY
The body of the request.
NOTE: This option needs to be used with the '-H/--headers' option in some frameworks
-F/--form FORM
Upload a form (multipart/form-data). The form options can be a JSON string like
'{ "field 1": { "type": "text", "value": "a text value"}, "field 2": { "type": "file", "path": "path to the file" } }'
or a path to a JSON file containing the form options.
When uploading a file the default filename value can be overridden by using the corresponding option:
'{ "field name": { "type": "file", "path": "path to the file", "options": { "filename": "myfilename" } } }'
Passing the filepath to the form can be done by using the corresponding option:
'{ "field name": { "type": "file", "path": "path to the file", "options": { "filepath": "/some/path/myfilename" } } }'
-i/--input FILE
The body of the request. See '-b/body' for more details.
-H/--headers K=V
The request headers.
--har FILE
When provided, Autocannon will use requests from the HAR file.
CAUTION: you have to specify one or more domains using URL option: only the HAR requests to the same domains will be considered.
NOTE: you can still add extra headers with -H/--headers but -m/--method, -F/--form, -i/--input -b/--body will be ignored.
-B/--bailout NUM
The number of failures before initiating a bailout.
-M/--maxConnectionRequests NUM
The max number of requests to make per connection to the server.
-O/--maxOverallRequests NUM
The max number of requests to make overall to the server.
-r/--connectionRate NUM
The max number of requests to make per second from an individual connection.
-R/--overallRate NUM
The max number of requests to make per second from all connections.
connection rate will take precedence if both are set.
NOTE: if using rate limiting and a very large rate is entered which cannot be met, Autocannon will do as many requests as possible per second.
Also, latency data will be corrected to compensate for the effects of the coordinated omission issue.
If you are not familiar with the coordinated omission issue, you should probably read [this article](http://highscalability.com/blog/2015/10/5/your-load-generator-is-probably-lying-to-you-take-the-red-pi.html) or watch this [Gil Tene's talk](https://www.youtube.com/watch?v=lJ8ydIuPFeU) on the topic.
-C/--ignoreCoordinatedOmission
Ignore the coordinated omission issue when requests should be sent at a fixed rate using 'connectionRate' or 'overallRate'.
NOTE: it is not recommended to enable this option.
When the request rate cannot be met because the server is too slow, many request latencies might be missing and Autocannon might report a misleading latency distribution.
-D/--reconnectRate NUM
The number of requests to make before resetting a connections connection to the
server.
-n/--no-progress
Don't render the progress bar. default: false.
-l/--latency
Print all the latency data. default: false.
-I/--idReplacement
Enable replacement of `[<id>]` with a randomly generated ID within the request body. e.g. `/items/[<id>]`. default: false.
-j/--json
Print the output as newline delimited JSON. This will cause the progress bar and results not to be rendered. default: false.
-f/--forever
Run the benchmark forever. Efficiently restarts the benchmark on completion. default: false.
-s/--servername
Server name for the SNI (Server Name Indication) TLS extension. Defaults to the hostname of the URL when it is not an IP address.
-x/--excludeErrorStats
Exclude error statistics (non-2xx HTTP responses) from the final latency and bytes per second averages. default: false.
-E/--expectBody EXPECTED
Ensure the body matches this value. If enabled, mismatches count towards bailout.
Enabling this option will slow down the load testing.
--renderStatusCodes
Print status codes and their respective statistics.
--cert
Path to cert chain in pem format
--key
Path to private key for specified cert in pem format
--ca
Path to trusted ca certificates for the test. This argument accepts both a single file as well as a list of files
--debug
Print connection errors to stderr.
-v/--version
Print the version number.
-V/--verbose
Print the table with results. default: true.
-h/--help
Print this menu.A Autocannon produz dados em tabelas como esta:
Running 10s test @ http://localhost:3000 10 connections ┌─────────┬──────┬──────┬───────┬──────┬─────────┬─────────┬──────────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼──────┼─────────┼─────────┼──────────┤ │ Latency │ 0 ms │ 0 ms │ 0 ms │ 1 ms │ 0.02 ms │ 0.16 ms │ 16.45 ms │ └─────────┴──────┴──────┴───────┴──────┴─────────┴─────────┴──────────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤ │ Req/Sec │ 20623 │ 20623 │ 25583 │ 26271 │ 25131.2 │ 1540.94 │ 20615 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤ │ Bytes/Sec │ 2.29 MB │ 2.29 MB │ 2.84 MB │ 2.92 MB │ 2.79 MB │ 171 kB │ 2.29 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘ Req/Bytes counts sampled once per second. 251k requests in 10.05s, 27.9 MB read
Existem duas tabelas: uma para a latência da solicitação e outra para o volume de solicitação.
A tabela de latência lista os tempos de solicitação no percentil de 2,5%, os valores extremos rápidos; a 50%, a mediana; em 97,5%, os outliers lentos; com 99%, os outliers mais lentos. Aqui, menor significa mais rápido.
A tabela de volume de solicitação lista o número de solicitações enviadas e o número de bytes baixados. Esses valores são amostrados uma vez por segundo. Valores mais altos significam que mais solicitações foram processadas. No exemplo acima, 2,29 MB foi baixado em 1 segundo no pior caso (1%mais lento). Como executamos apenas 10 segundos, existem apenas 10 amostras, o valor mínimo e os percentis de 1% e 2,5% são todos da mesma amostra. Com durações mais longas, esses números diferirão mais.
Ao passar a bandeira -l , uma terceira tabela lista todos os percentis de latência registrados pela Autocannon:
┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 0 │ ├────────────┼──────────────┤ │ 1 │ 0 │ ├────────────┼──────────────┤ │ 2.5 │ 0 │ ├────────────┼──────────────┤ │ 10 │ 0 │ ├────────────┼──────────────┤ │ 25 │ 0 │ ├────────────┼──────────────┤ │ 50 │ 0 │ ├────────────┼──────────────┤ │ 75 │ 0 │ ├────────────┼──────────────┤ │ 90 │ 0 │ ├────────────┼──────────────┤ │ 97.5 │ 0 │ ├────────────┼──────────────┤ │ 99 │ 1 │ ├────────────┼──────────────┤ │ 99.9 │ 1 │ ├────────────┼──────────────┤ │ 99.99 │ 3 │ ├────────────┼──────────────┤ │ 99.999 │ 15 │ └────────────┴──────────────┘
Isso pode dar mais informações se muito (milhões) de solicitações foram enviadas.
'Use Strict'Const Autocannon = requer (' Autocannon ') Autocannon ({
URL: 'http: // localhost: 3000',
Conexões: 10, // Padrão
Pipelining: 1, // Padrão
Duração: 10 // Padrão}, Console.log) // Async/Awaitasync Função Foo () {
const resultado = aguarda Autocannon ({url: 'http: // localhost: 3000', conexões: 10, // defaultPipelining: 1, // defaultDuration: 10 // Padrão
})
console.log (resultado)} No modo Workers, autocannon usa instâncias da classe de trabalhadores do Node para executar os testes de carga em vários threads.
Os parâmetros amount e connections são divididos entre os trabalhadores. Se qualquer um dos parâmetro não for divisível pelo número de workers , o valor por trabalhador será arredondado para o número inteiro mais baixo, ou definido como 1 , o que for o maior. Todos os outros parâmetros são aplicados por trabalhador, como se o teste fosse um thread único.
NOTA: Diferentemente amount e connections , os parâmetros "gerais", maxOverallRequests e overallRate , são aplicados por trabalhador . Por exemplo, se você definir connections para 4 , workers para 2 e maxOverallRequests como 10 , cada trabalhador receberá 2 conexões e um maxOverallRequests de 10 , resultando em 20 solicitações sendo enviadas.
'Use Strict'Const Autocannon = requer (' Autocannon ') Autocannon ({
URL: 'http: // localhost: 3000',
Conexões: 10, // Padrão
Pipelining: 1, // Padrão
Duração: 10, // Padrão
trabalhadores: 4}, console.log) Nota: Quando no modo trabalhador, você precisa passar em um caminho de arquivo absoluto para todas as opções que aceitam uma function . Isso ocorre porque uma função passada para o processo principal não pode ser clonada e passada para o trabalhador. Então, em vez disso, ele precisa de um arquivo que ele possa require . As opções com esse comportamento são mostradas no exemplo abaixo
'Use Strict'Const Autocannon = requer (' Autocannon ') Autocannon ({
// ...
Trabalhadores: 4,
SetupClient: '/full/path/to/setup-client.js',
Verifique se: '/full/path/to/verify-body.js'
Solicitações: [{// ... OnResponse: '/full/path/to/on-rosponse.js'}, {// ... setuprequest: '/full/path/to/setup-request.js'}
]}, console.log)Inicie o Autocannon contra o alvo fornecido.
opts : Opções de configuração para a instância do AutoCannon. Isso pode ter os seguintes atributos. OBRIGATÓRIO .
body : Quando presente, substituirá opts.body . OPCIONAL
headers : Quando presente, substituirá opts.headers . OPCIONAL
method : Quando presente, substituirá opts.method . OPCIONAL
path : Quando presente, substituirá opts.path . OPCIONAL
setupRequest : uma Function que você pode fornecer para muta o objeto RAW request , por exemplo, request.method = 'GET' . É necessário parâmetros request (objeto) e context (objeto) e deve retornar a solicitação modificada. Quando retornar um valor falso, o Autocannon reiniciará a partir da primeira solicitação. Ao usar workers , você precisa fornecer um caminho de arquivo que exporte uma função (confira a seção dos trabalhadores para obter mais detalhes) opcional
onResponse : uma Function que você pode fornecer para processar a resposta recebida. É necessário parâmetros e headers context status (número), body (string) (objeto) (objeto de valor-chave). Ao usar workers , você precisa fornecer um caminho de arquivo que exporte uma função (confira a seção dos trabalhadores para obter mais detalhes) opcional
url : o alvo fornecido. Pode ser http ou https. Mais de um URL é permitido, mas é recomendável que o número de conexões seja um múltiplo inteiro do URL. OBRIGATÓRIO .
socketPath : um caminho para um soquete de domínio UNIX ou um tubo de janelas chamado. Um url ainda é obrigado a enviar o cabeçalho e o caminho corretos do host. Opcional .
workers : Número de fios de trabalhador a serem usados para disparar solicitações.
connections : o número de conexões simultâneas. Padrão opcional : 10 .
duration : o número de segundos para executar o Autocannon. Pode ser um tempo de tempo. Padrão opcional : 10 .
amount : um Number informando o número de solicitações a serem feitas antes de terminar o teste. Isso substitui a duração e tem precedência, para que o teste não termine até que o número de solicitações precisasse ser concluído seja concluído. Opcional .
sampleInt : o número de milissegundos para decorrer entre as amostras. Isso controla o intervalo da amostra e, portanto, o número total de amostras, que afeta as análises estatísticas. Padrão: 1.
timeout : o número de segundos para aguardar uma resposta antes. Padrão opcional : 10 .
pipelining : o número de solicitações de pipeline para cada conexão. Fará com que a API Client jogue quando maior que 1. Padrão opcional : 1 .
bailout : o limite do número de erros ao fazer as solicitações ao servidor antes da fiança desta instância. Esta instância levará todos os resultados existentes até agora e os agregará nos resultados. Se ninguém passou aqui, a instância ignorará erros e nunca resgatará. Padrão opcional : undefined .
method : o método HTTP a ser usado. Padrão opcional default: 'GET' .
title : Uma String a ser adicionada aos resultados para identificação. Padrão opcional : undefined .
body : uma String ou um Buffer que contém o corpo da solicitação. Insira um ou mais IDs gerados aleatoriamente no corpo, incluindo [<id>] , onde o ID gerado aleatoriamente deve ser inserido (também deve definir o lançamento no verdadeiro). Isso pode ser útil no teste dos pontos de extremidade dos testes, onde um ou mais campos devem ser únicos. Deixe indefinido para um corpo vazio. Padrão opcional : undefined .
form : uma String ou um Object que contém as opções de multipart/formato ou um caminho para o arquivo json que os contém
headers : um Object que contém os cabeçalhos da solicitação. Padrão opcional : {} .
initialContext : um objeto com o qual você gostaria de inicializar seu contexto. Confira um exemplo de contexto de inicialização. OPCIONAL
setupClient : uma Function que será passada o objeto Client para que cada conexão seja feita. Isso pode ser usado para personalizar cada cabeçalhos de conexão individuais e corpo usando a API mostrada abaixo. As mudanças que você faz para o cliente nesta função terão precedência sobre o body e headers padrão que você passa aqui. Há um exemplo disso na pasta de amostras. Padrão opcional : function noop () {} . Ao usar workers , você precisa fornecer um caminho de arquivo que exporte uma função (consulte a seção dos trabalhadores para obter mais detalhes).
verifyBody : uma Function que será passada no corpo de resposta para cada solicitação concluída. Cada solicitação, cuja função verifyBody não retorna um valor verdadeiro, é contado em mismatches . Esta função terá precedência sobre o expectBody . Há um exemplo disso na pasta de amostras. Ao usar workers , você precisa fornecer um caminho de arquivo que exporte uma função (consulte a seção dos trabalhadores para obter mais detalhes).
maxConnectionRequests : um Number indicando as solicitações máximas a serem feitas por conexão. amount tem precedência se ambos estiverem definidos. OPCIONAL
maxOverallRequests : um Number declarando as solicitações máximas para fazer em geral. Não pode ser menos que connections . maxConnectionRequests tem precedência se ambos forem definidos. OPCIONAL
connectionRate : um Number informando a taxa de solicitações a serem feitas por segundo de cada conexão individual. Sem limitação de taxa por padrão. OPCIONAL
overallRate : um Number informando a taxa de solicitações a serem feitas por segundo de todas as conexões. connectionRate tem precedência se ambos estiverem definidos. Sem limitação de taxa por padrão. OPCIONAL
ignoreCoordinatedOmission : Um Boolean que desativa a correção de latências para compensar a questão da omissão coordenada. Não faz sentido quando nenhuma taxa de solicitações foi especificada ( connectionRate ou overallRate ). Padrão opcional : false .
reconnectRate : um Number que faz com que as conexões individuais se desconectem e se reconectem ao servidor sempre que enviar esse número de solicitações. OPCIONAL
requests : uma Array de Object S que representa a sequência de solicitações a serem feitas durante o benchmarking. Pode ser usado em conjunto com o body , headers e parâmetros method acima. Verifique a pasta de amostras para um exemplo de como isso pode ser usado. Opcional . Objetos contidos podem ter esses atributos:
har : Um Object de conteúdo de HAR analisado. form AutoCannon requests extra method body entries.request Nota : você deve garantir que as entradas estejam visando o mesmo domínio que a opção url . OPCIONAL
idReplacement : Um Boolean que permite a substituição de tags [<id>] dentro do corpo da solicitação com um ID gerado aleatoriamente, permitindo que os campos exclusivos sejam enviados com solicitações. Confira um exemplo de uso programático que pode ser encontrado nas amostras. Padrão opcional : false
forever : Um Boolean que permite configurar uma instância do Autocannon que reinicie indefinidamente após emitir resultados com o evento done . Útil para reiniciar com eficiência sua instância. Para parar de correr para sempre, você deve causar um SIGINT ou chamar a função .stop() em sua instância. Padrão opcional : false
servername : uma String que identifica o nome do servidor para a extensão SNI (indicação do nome do servidor) TLS. Padrão opcional : Padrões no nome do host da URL quando não é um endereço IP.
excludeErrorStats : um Boolean que permite desativar as respostas de código não 2xx em latência e bytes por segundo cálculos. Padrão opcional : false .
expectBody : uma String que representa o corpo de resposta esperado. Cada solicitação cujo corpo de resposta não é igual ao expectBody é contado em mismatches . Se ativado, as incompatibilidades contam para o resgate. OPCIONAL
tlsOptions : Um Object que é passado para tls.connect Call (Lista completa de opções). Nota: isso se aplica apenas se o seu URL estiver seguro.
skipAggregateResult : um Boolean que permite desativar a fase de resultados agregados de uma instância. Consulte Autocannon.AGregateSult
cb : O retorno de chamada que é chamado após a conclusão de uma referência. Pega os seguintes parâmetros. Opcional .
err : Se houve um erro encontrado com a execução.
results : Os resultados da execução.
Retorna um emissor de instância/evento para rastrear o progresso, etc. Se cb for omitido, o valor de retorno também poderá ser usado como uma promessa.
Ao executar, o Autocannon criará tantos objetos Client quanto as conexões desejadas. Eles serão executados em paralelo até que a referência termine (duração ou número total de solicitações). Cada cliente irá percorrer a matriz requests , conteria uma ou várias solicitações.
Ao passar pelas solicitações disponíveis, o cliente manterá um context : um objeto que você pode usar nas funções onResponse e setupRequest , para armazenar e ler alguns dados contextuais. Verifique o arquivo request-context.js em amostras.
Observe que o objeto context será redefinido para initialContext (ou {} não é fornecido) ao reiniciar a primeira solicitação disponível, garantindo execuções semelhantes.
Ao combinar uma amount fixa de solicitações com connections simultâneas e um limite overallRate , o AutoCannon distribuirá as solicitações e a taxa pretendida em todas as conexões. Se a overallRate não for divisível inteira, o Autocannon configurará alguns clientes de conexão com um maior e alguns com um número menor de solicitações/segunda taxa. Se agora o amount for divisível inteiro, todos os clientes de conexão obterão o mesmo número de solicitações. Isso significa que os clientes com uma taxa de solicitação mais alta terminarão mais cedo do que os outros, levando a uma queda na taxa de solicitação percebida.
Exemplo: connections = 10, overallRate = 17, amount = 5000
Acompanhe o progresso do seu Autocannon, programaticamente.
instance : a instância do Autocannon. OBRIGATÓRIO .
opts : Opções de configuração para rastreamento. Isso pode ter os seguintes atributos. Opcional .
outputStream : o fluxo para a saída. Padrão: process.stderr .
renderProgressBar : um valor verdadeiro para permitir a renderização da barra de progresso. Padrão: true .
renderResultsTable : um valor verdadeiro para permitir a renderização da tabela de resultados. Padrão: true .
renderLatencyTable : um valor verdadeiro para permitir a renderização da tabela de latência avançada. Padrão: false .
progressBarString : uma string que define o formato da saída da exibição de progresso. Deve ser uma entrada válida para o módulo da barra de progresso. Padrão: 'running [:bar] :percent' .
Exemplo que apenas imprime a tabela de resultados na conclusão:
'Use Strict'Const Autocannon = requer (' Autocannon ') const instância = AutoCannon ({
URL: 'http: // localhost: 3000'}, console.log) // Isso é usado para matar a instância em ctrl-cprocess.once ('sigint', () => {
instance.stop ()}) // Apenas renderize resultadosConfira este exemplo para vê -lo em uso também.
Retorna uma sequência de texto que contém as tabelas de resultado.
resultObject : o objeto de resultado do Autocannon. OBRIGATÓRIO .
opts : Opções de configuração para gerar as tabelas. Estes podem incluir os seguintes atributos. Opcional .
outputStream : o fluxo para o qual a saída é direcionada. É usado principalmente para verificar se o terminal suporta a cor. Padrão: process.stderr .
renderResultsTable : um valor verdadeiro para permitir a criação da tabela de resultados. Padrão: true .
renderLatencyTable : um valor verdadeiro para permitir a criação da tabela de latência. Padrão: false .
Exemplo:
"Use Strict"; const {stdout} = requer ("nó: process"); const autocannon = require ("autocannon"); função print (resultado) {
stdout.write (autocannon.printresult (resultado));} autocannon ({url: "http: // localhost: 3000"}, (err, resultado) => print (resultado)); Agregue os resultados de uma ou mais execuções de instância do AutoCannon, onde as instâncias do AutoCannon foram executadas com a opção skipAggregateResult .
Este é um caso de uso avançado, onde você pode estar executando um teste de carga usando o Autocannon em várias máquinas e, portanto, precisa adiar a agregação dos resultados a um período posterior.
results : Uma matriz de resultados da instância do AutoCannon, onde as instâncias foram executadas com a opção skipAggregateResult definida como true. OBRIGATÓRIO .
opts : Este é um subconjunto das opções que você passaria para a API principal do Autocannon, para que você possa usar o mesmo objeto de opções que o usado para executar as instâncias. Consulte o Autocannon para obter descrições completas das opções. OBRIGATÓRIO .
url : Necessário
title : Padrão opcional : undefined
socketPath : Opcional
connections : Padrão opcional : 10 .
sampleInt : Padrão opcional : 1
pipelining : Padrão opcional : 1
workers : Padrão opcional : undefined
Como uma instância do Autocannon é uma EventEmitter , ela emite vários eventos. Estes estão abaixo:
start : Emitido depois que tudo estiver configurado na sua instância do AutoCannon e ele começou. Útil para se executar a instância para sempre.
tick : Emitido a cada segundo, este Autocannon está executando uma referência. Útil para exibir estatísticas, etc. usado pela função track . O evento tick propaga um objeto que contém os valores counter e bytes , que podem ser usados para relatórios estendidos.
done : Emitido quando o Autocannon termina uma referência. passa os results como um argumento para o retorno de chamada.
response : Emitida quando os Autocanns HTTP-Client recebe uma resposta HTTP do servidor. Isso passa os seguintes argumentos para o retorno de chamada:
client : o próprio http-client . Pode ser usado para modificar os cabeçalhos e o corpo que o cliente enviará para o servidor. API abaixo.
statusCode : o código de status HTTP da resposta.
resBytes : o comprimento do byte de resposta.
responseTime : o tempo necessário para obter uma resposta depois de iniciar a solicitação.
reqError : emitido no caso de um erro de solicitação, por exemplo, um tempo limite.
error : emitido se houver um erro durante a fase de configuração do AutoCannon.
O objeto de resultados emitido por done e passou para o retorno de chamada do autocannon() tem essas propriedades:
title : Valor da opção title passada para autocannon() .
url : O URL que foi direcionado.
socketPath : o soquete do domínio UNIX ou Windows chamado Pipe que foi direcionado ou undefined .
requests : Um objeto histograma que contém estatísticas sobre o número de solicitações enviadas por segundo.
latency : Um objeto de histograma que contém estatísticas sobre a latência da resposta.
throughput : Um objeto histograma que contém estatísticas sobre a taxa de transferência de dados de resposta por segundo.
duration : a quantidade de tempo que o teste levou, em segundos .
errors : o número de erros de conexão (incluindo tempo limite) que ocorreram.
timeouts : o número de tempo limite de conexão que ocorreu.
mismatches : o número de solicitações com um corpo incompatível.
start : um objeto de data representando quando o teste foi iniciado.
finish : um objeto de data representando quando o teste terminou.
connections : a quantidade de conexões usadas (valor de opts.connections ).
pipelining : o número de solicitações de pipeline usadas por conexão (valor do opts.pipelining ).
non2xx : o número de códigos de status de resposta não 2xx recebidos.
resets : quantas vezes o pipeline de solicitações foi redefinido devido ao setupRequest retornar um valor falso.
statusCodeStats : Solicitações Contador por código de status (por exemplo { "200": { "count": "500" } } )
Os objetos do histograma para requests , latency e throughput são objetos de HDR-Histogram-percentilos-OBJ e têm essa forma:
min : o menor valor para esta estatística.
max : O valor mais alto para esta estatística.
average : o valor médio (médio).
stddev : O desvio padrão.
p* : O valor do percentil xxth para esta estatística. As propriedades do percentil são: p2_5 , p50 , p75 , p90 , p97_5 , p99 , p99_9 , p99_99 , p99_999 .
Client Este objeto é passado como o primeiro parâmetro da função setupClient e do evento response a partir de uma instância do AutoCannon. Você pode usar isso para modificar as solicitações que está enviando durante o benchmarking. Este também é um EventEmitter , com os eventos e seus parâmetros listados abaixo.
client.setHeaders(headers) : Usado para modificar os cabeçalhos da solicitação que este iterador do cliente está ativado atualmente. headers devem ser um Object ou undefined se você quiser remover seus cabeçalhos.
client.setBody(body) : usado para modificar o corpo da solicitação que este iterador do cliente está ativado atualmente. body deve ser uma String ou Buffer ou undefined se você quiser remover o corpo.
client.setHeadersAndBody(headers, body) : usado para modificar os cabeçalhos e o corpo que esse iterador do cliente está ativado atualmente. headers e body devem assumir a mesma forma que acima.
client.setRequest(request) : Usado para modificar toda a solicitação de que esse iterador do cliente esteja atualmente. Pode ter headers , body , method ou path como atributos. Os padrões para os valores passados para a instância do AutoCannon quando foram criados. Note: call this when modifying multiple request values for faster encoding
client.setRequests(newRequests) : usado para substituir toda a matriz de solicitações que foi transmitida para a instância no início. Note: call this when modifying multiple requests for faster encoding
Client Os eventos que um Client pode emitir estão listados aqui:
headers : Emitido quando uma solicitação enviada desse cliente recebeu os cabeçalhos de sua resposta. Isso recebeu um Object como parâmetro.
body : emitido quando uma solicitação enviada desse cliente recebeu o corpo de uma resposta. Isso recebe um Buffer como parâmetro.
response : Emitida quando o cliente recebeu uma resposta concluída para uma solicitação que fez. Isso passou os seguintes argumentos:
statusCode : o código de status HTTP da resposta.
resBytes : o comprimento do byte de resposta.
responseTime : o tempo necessário para obter uma resposta depois de iniciar a solicitação.
reset : emitido quando o pipeline de solicitações foi redefinido devido ao setupRequest retornar um valor falso.
Exemplo usando os eventos autocannon e a API e eventos do cliente:
'Use Strict'Const Autocannon = requer (' Autocannon ') const instância = AutoCannon ({
URL: 'http: // localhost: 3000',
SetupClient: SetupClient}, (err, resultado) => handleResults (resultado)) // Os resultados passados para o retorno de chamada são os mesmos que os emitidos do EventsInsinStance.on ('done', HandleResults) Instância.on ('Tick' , () => console.log ('ticking')) instance.on ('resposta', manutenção de manutenção) SetupClient (client) {
client.on ('body', console.log) // console.log um corpo de resposta quando o manutenção de função recebida} (cliente, statusCode, resbytes, ResponseTime) {
console.log (`obteve resposta com código $ {statusCode} em $ {ResponseTime} milisEconds`)
console.log (`Resposta: $ {resbytes.toString ()}`)
// Atualize o corpo ou cabeçalhos
client.setheaders ({new: 'header'})
client.setbody ('novo corpo')
client.setheadersandbody ({new: 'header'}, 'new body')} manipuladores de função (resultado) {
// ...} O Autocannon está escrito em JavaScript para o Node.js Runtime Runtime e está ligado à CPU. Verificamos que ele produz resultados comparáveis com wrk quando os aplicativos de benchmarking node.js usando o módulo http . No entanto, ele usa significativamente mais CPU do que outras ferramentas que compilam a um binário como wrk . O Autocannon pode saturar a CPU, por exemplo, o processo autocannon atinge 100%: nesses casos, recomendamos o uso wrk2 .
Como exemplo, vamos considerar uma corrida com 1000 conexões em um servidor com 4 núcleos com hiperthreading:
wrk usa 2 threads (por padrão) e um auxiliar para coletar as métricas com uma carga total da CPU de 20% + 20% + 40%.
autocannon usa um único encadeamento a 80% da carga da CPU.
Ambos saturam um processo node.js em cerca de 41k Req/s, no entanto, autocannon pode saturar mais cedo porque é um thread único.
Observe que wrk não suporta Pipelining HTTP/1.1. Como resultado, autocannon pode criar mais carga no servidor do que o WRK para cada conexão aberta.
Este projeto foi gentilmente patrocinado pela próxima forma.
Logotipo e identidade projetados pela Cosmic Fox Design: https://www.behance.net/cosmicfox.
WRK e WRK2 forneceram grande inspiração.
Se você estiver usando a Autocannon ou tiver alguma dúvida, informe -nos: Gitter
Glen Keane | Github
Salman Mitha | Github | Npm
Copyright Matteo Collina e outros colaboradores, licenciados pelo MIT.
