Packages
electric
1.5.1
1.7.7
1.7.6
1.7.5
1.7.4
1.7.3
1.7.2
1.7.1
1.7.0
1.6.10
1.6.9
1.6.8
1.6.7
1.6.6
1.6.5
1.6.4
1.6.3
1.6.2
1.6.1
1.6.0
1.5.1
1.5.0
1.4.16
1.4.16-beta-1
1.4.15
1.4.14
1.4.13
1.4.12
1.4.11
1.4.10
1.4.8
1.4.7
1.4.6
1.4.5
1.4.4
1.4.3
1.4.2
1.4.1
1.4.0
1.3.4
1.3.3
1.3.2
1.2.4
1.2.3
1.2.2
1.2.1
1.2.0
1.1.14
1.1.13
1.1.12
1.1.11
1.1.10
1.1.9
1.1.8
1.1.7
1.1.6
retired
1.1.5
retired
1.1.4
retired
1.1.3
retired
1.1.2
1.1.1
1.1.0
1.0.24
1.0.23
1.0.22
1.0.21
1.0.20
1.0.19
1.0.18
1.0.17
1.0.15
1.0.13
1.0.12
1.0.11
1.0.10
1.0.9
1.0.5
1.0.4
1.0.3
1.0.2
1.0.1
1.0.0
1.0.0-beta.23
1.0.0-beta.22
1.0.0-beta.20
1.0.0-beta.19
1.0.0-beta.18
1.0.0-beta.17
1.0.0-beta.16
1.0.0-beta.15
1.0.0-beta.14
1.0.0-beta.13
1.0.0-beta.12
1.0.0-beta.11
1.0.0-beta.10
1.0.0-beta.9
1.0.0-beta.8
1.0.0-beta.7
1.0.0-beta.6
1.0.0-beta.5
1.0.0-beta.4
1.0.0-beta.3
1.0.0-beta.2
1.0.0-beta.1
0.9.5
0.9.4
0.9.3
0.9.2
0.9.1
0.9.0
0.8.1
0.8.0
0.7.7
0.7.6
0.7.5
0.7.4
0.7.3
0.7.2
0.7.1
0.7.0
0.6.3
0.6.2
0.6.1
0.5.2
0.4.4
Postgres sync engine. Sync little subsets of your Postgres data into local apps and services.
Current section
Files
Jump to
Current section
Files
lib/electric/interval_timer.ex
defmodule Electric.Telemetry.IntervalTimer do
@moduledoc """
Times intervals between calls to `start_interval/2`. This is useful if you
want to find out which part of a process took the longest time. It works
out simpler than wrapping each part of the process in a timer, and
guarentees no gaps in the timings.
The simplest way to use the timer is to store the timer state in the
process memory, see `OpenTelemetry.start_interval`. This module should
only be used directly if you do not want to use the process memory.
"""
@type t() :: [{term(), non_neg_integer()}]
def init, do: []
def start_interval(state, interval_name, opts \\ [])
def start_interval(nil, _, _), do: nil
def start_interval(state, interval_name, opts) do
[{interval_name, time(opts)} | state]
end
def durations(state, opts \\ [])
def durations(nil, _), do: %{}
def durations(state, opts) do
calculate_durations(state, time(opts))
|> Enum.group_by(
fn {interval_name, _} -> interval_name end,
fn {_, duration} -> duration end
)
|> Map.new(fn {interval_name, durations} ->
{interval_name, Enum.sum(durations)}
end)
end
def total_time(durations) when durations == %{}, do: 0
def total_time(durations) do
durations
|> Enum.map(fn {_, duration} -> duration end)
|> Enum.sum()
end
defp calculate_durations([{interval_name, start_time} | rest], end_time) do
duration = {interval_name, end_time - start_time}
# since we're moving backwards through the intervals, the next interval's end time
# is this interval's start time:
[duration | calculate_durations(rest, _next_interval_end_time = start_time)]
end
defp calculate_durations([], _), do: []
defp time(opts) do
opts[:time] || time()
end
def time, do: System.monotonic_time(:microsecond)
end