anchor.diff:      traffic_in_resolver/0,
       traffic_out_resolver/0,
       connections_in_resolver/0,
  -    connections_out_resolver/0
  +    connections_out_resolver/0,
  +    latency_mean_resolver/0,
  +    latency_min_resolver/0,
  +    latency_95_resolver/0,
  +    latency_99_resolver/0,
  +    latency_99_5_resolver/0,
  +    latency_max_resolver/0,
  +    latency_connect_mean_resolver/0,
  +    latency_connect_min_resolver/0,
  +    latency_connect_95_resolver/0,
  +    latency_connect_99_resolver/0,
  +    latency_connect_99_5_resolver/0,
  +    latency_connect_max_resolver/0
   ]).
   
   -define(Timeout, 5000).
  
positive.code:                       metrics => [
                                    {"tcpkali.connections.total.in", derived, #{resolver => connections_in_resolver}},
                                    {"tcpkali.connections.total.out", derived, #{resolver => connections_out_resolver}}
                                    ]}}
          ]}
      ].
  
  traffic_in_resolver() ->
      aggregate_sum("tcpkali.traffic.bitrate.in").
  
  traffic_out_resolver() ->
      aggregate_sum("tcpkali.traffic.bitrate.out").
  
  connections_in_resolver() ->
      aggregate_sum("tcpkali.connections.total.in").
  
  connections_out_resolver() ->
      aggregate_sum("tcpkali.connections.total.out").
  
  aggregate_sum(Name) ->
      case get_metric("tcpkali.pools_num", undefined) of
          undefined -> erlang:error(undefined_number_of_pools);
          Pools ->
  
negative.code:                     Workers = get_metric("tcpkali.workers_num.pool~b", [P], 0),
                      lists:foldl(
                          fun (W, Acc2) ->
                              Fun(get_metric("~s.~b.~b", [Name, P, W], 0), P, W, Acc2)
                          end, Acc1, lists:seq(1, Workers))
                  end, InitialAcc, lists:seq(1, Pools))
      end.
  
  get_metric(Format, Args, Default) ->
  