Review my code - duration measurement & convert to a human easy readable scientific format

Hi all, as I’m always trying to improve my code.
Is anyone of you Elixir Pros interested into review my following code?

This module will convert duration measurements into a human easy readable scientific format.
What I mean by this.
I always hated if an uptime / or downtime measurement told me e.g. up since 1 y 21 d 5 h 5 min 5 s.
In this case 1 y 21 d would be totally enough for myself.

So the conversion scheme I’m using here is very opinionated.
In case of any unit value below 10, I will additionally add the value of the next unit. Above I don’t.
e.g.

- `1 s _ ms` - `9 s _ ms`
- `10 s ` - `59 s`

I would be very thankful if anybody would give me his opinion to my code below.
If you would do something in Elixir best practice completely different for this use case …

defmodule Tool.Timer do
  @moduledoc """
  Time measurement tool for performance & uptime testing.
  Can convert a duration to a human easy understandable scientific format.
  """

  @base_unit :nanosecond
  @unit_shift_factor 10

  @second 1
  @minute @second * 60
  @hour @minute * 60
  @day @hour * 24
  @year @day * 365

  @doc """
  Returns monotonic system time in @base_unit
  """
  @spec now() :: integer()
  def now, do: System.monotonic_time(@base_unit)

  @doc """
  Calculate time difference to a given start time (e.g. from `now/0`).
  Return duration in @base_unit.
  """
  @spec diff(integer(), integer()) :: integer()
  def diff(start_time, end_time \\ now()) do
    end_time - start_time
  end

  @doc """
  Calculate time difference to a given start time (e.g. from `now/0`).
  Return duration in a human easy understandable scientific format.
  In: `-576460349095935368`
  Out:
  - `1 ns` - `999 ns`
  - `1 μs _ ns` - `9 μs _ ns`
  - `10 μs` - `999 μs`
  - `1 ms _ μs` - `9 ms _ μs`
  - `10 ms ` - `999 ms`
  - `1 s _ ms` - `9 s _ ms`
  - `10 s ` - `59 s`
  - `1 min _ s` - `59 min _ s`
  - `1 h _ min` - `23 h _ min`
  - `1 d _ h` - `364 d _ h`
  - `1 y _ d` - `_ y _ d`
  """
  @spec diff_human(integer(), integer(), System.time_unit()) :: binary()
  def diff_human(start_time, end_time \\ now(), base_unit \\ @base_unit) do
    diff_base = diff(start_time, end_time)
    diff_nano = System.convert_time_unit(diff_base, base_unit, :nanosecond)
    time_conversion(diff_nano)
  end

  # everything below system precision
  defp time_conversion(time) when time === 0,
    do: "< #{system_precision()}"

  # nanoseconds (ns) only
  defp time_conversion(time) when time < 1_000,
    do: unit_fraction_string(time, :nanosecond)

  # microseconds (μs) + nanoseconds (ns)
  defp time_conversion(time) when time < 1_000 * @unit_shift_factor do
    list_to_string([
      unit_fraction_string(time, :microsecond),
      unit_fraction_string(time, :nanosecond)
    ])
  end

  # microseconds (μs) only
  defp time_conversion(time) when time < 1_000_000,
    do: unit_fraction_string(time, :microsecond)

  # milliseconds (ms) + microseconds (μs)
  defp time_conversion(time) when time < 1_000_000 * @unit_shift_factor do
    list_to_string([
      unit_fraction_string(time, :millisecond),
      unit_fraction_string(time, :microsecond)
    ])
  end

  # milliseconds (ms) only
  defp time_conversion(time) when time < 1_000_000_000,
    do: unit_fraction_string(time, :millisecond)

  # seconds (s) + milliseconds (ms)
  defp time_conversion(time) when time < 1_000_000_000 * @unit_shift_factor do
    list_to_string([
      unit_fraction_string(time, :second),
      unit_fraction_string(time, :millisecond)
    ])
  end

  # seconds (s) only
  defp time_conversion(time) when time < @minute * 1_000_000_000,
    do: unit_fraction_string(time, :second)

  # minutes (min) + seconds (s)
  defp time_conversion(time) when time < @hour * 1_000_000_000 do
    list_to_string([
      unit_subset_fraction_string(time, :minute, @minute, 60),
      unit_subset_fraction_string(time, :second, @second, 60)
    ])
  end

  # hours (h) + minutes (min)
  defp time_conversion(time) when time < @day * 1_000_000_000 do
    list_to_string([
      unit_subset_fraction_string(time, :hour, @hour, 60),
      unit_subset_fraction_string(time, :minute, @minute, 60)
    ])
  end

  # days (d) + hours (h)
  defp time_conversion(time) when time < @year * 1_000_000_000 do
    list_to_string([
      unit_subset_fraction_string(time, :day, @day, 365),
      unit_subset_fraction_string(time, :hour, @hour, 24)
    ])
  end

  # years (y) + days (d)
  @spec time_conversion(integer()) :: binary()
  defp time_conversion(time) do
    list_to_string([
      unit_subset_fraction_string(time, :year, @year, 365),
      unit_subset_fraction_string(time, :day, @day, 365)
    ])
  end

  # will return the human readable system precision
  @spec system_precision :: binary
  defp system_precision do
    parts_per_second = System.convert_time_unit(1, :second, :native)
    precision_nano = round(1 / parts_per_second * 1_000_000_000)

    # to avoid a infinite loop on value 0
    precision =
      case precision_nano do
        x when x > 0 -> x
        _ -> 1
      end

    time_conversion(precision)
  end

  # unit fraction for everything below seconds
  @spec unit_fraction_string(integer(), atom()) :: binary()
  defp unit_fraction_string(time, unit) do
    fraction =
      time
      |> System.convert_time_unit(:nanosecond, unit)
      |> Integer.mod(1_000)

    human_readable_unit(fraction, unit)
  end

  # unit fraction for everything above seconds
  @spec unit_subset_fraction_string(integer(), atom(), integer(), integer()) :: binary()
  defp unit_subset_fraction_string(time, unit, fraction_divisor, subset_divisor) do
    fraction =
      time
      |> System.convert_time_unit(:nanosecond, :second)
      |> Integer.floor_div(fraction_divisor)
      |> Integer.mod(subset_divisor)

    human_readable_unit(fraction, unit)
  end

  # join value with unit
  @spec human_readable_unit(integer(), atom()) :: binary()
  defp human_readable_unit(fraction, unit) do
    cond do
      fraction > 0 -> Integer.to_string(fraction) <> " " <> unit_abbreviation(unit)
      true -> nil
    end
  end

  # unit abbreviations
  @spec unit_abbreviation(atom()) :: binary()
  defp unit_abbreviation(:nanosecond), do: "ns"
  defp unit_abbreviation(:microsecond), do: "μs"
  defp unit_abbreviation(:millisecond), do: "ms"
  defp unit_abbreviation(:second), do: "s"
  defp unit_abbreviation(:minute), do: "min"
  defp unit_abbreviation(:hour), do: "h"
  defp unit_abbreviation(:day), do: "d"
  defp unit_abbreviation(:year), do: "y"

  # join list to string
  @spec list_to_string(list()) :: binary()
  defp list_to_string(list) do
    list
    # remove nil values from list
    |> Enum.filter(& &1)
    |> Enum.join(" ")
  end
end

Edit:

• Updated with the already mentioned changes from david_ex.