🥇Vela → smart cache för tidsserier och mer

In fintech, we often have to process quite large volumes of currency exchange rate data. We obtain data from various sources, each of which has its own way of extrapolating values for tomorrow, the day after tomorrow, next month, and even the next three years. If someone could predict rates correctly, it would be time to close the business and simply exchange money back and forth. correctly, it would be time to close the business and just trade money back and forth. Some sources are more trusted, while others provide mostly junk, with rare instances of almost correct values, especially for exotic pairs. Our job is to sift through these tens of thousands of values per second and determine what to show our clients. We need to filter out the single correct value from a ton of dirt and mud, just like flamingos do during lunch.

A distinguishing feature of flamingos is their massive downturned beak, which they use to filter food from water or mud.
— Wiki

Thus, the library was born Vela, which holds a cache of states for multiple values over specified time intervals. Under the hood, it automatically filters out bad and outdated data while providing access to the latest N validated values for each key (currency pairs, in our case).

Let's say we are collecting rates for three currency pairs. The simplest definition Vela for storing the current state would look something like this:

defmodule Pairs do
  use Vela,
    eurusd: [sorter: &Kernel. 0
end

Updating values

Vela.put/3 the function will sequentially perform the following:

call validator on the value if it is defined (see chapter Validation below);
add the value to either the list of good values if validation was successful, or to the error queue :__errors__ otherwise;
call sorting if the sorter is defined for this key, or simply place the value at the head of the list (LIFO, see chapter Sortera below);
trim the list according to the parameter :limit passed during creation;
return the updated structure Vela.

iex|1 > par = %Pairs{}
iex|2 > Vela.put(par, :eurcad, 1.0)
#⇒ %Pairs{..., eurcad: [1.0], ...}
iex|3 > Vela.put(par, :eurcad, -1.0)
#⇒ %Pairs{__errors__: [eurcad: -1.0], ...}
iex|4 > par |> Vela.put(:eurusd, 2.0) |> Vela.put(:eurusd, 1.0)
#⇒ %Pairs{... eurusd: [1.0, 2.0]}

Även Vela implementerar Åtkomst, så att du kan använda någon av de standardfunktioner för djupuppdatering av strukturer från arsenalen Kernel: Kernel.get_in/2, Kernel.put_in/3, Kernel.update_in/3, Kernel.pop_in/2, och Kernel.get_and_update_in/3.

Validation

Validatorn kan definieras som:

en extern funktion med ett argument (&MyMod.my_fun/1), den kommer endast att få värdet för validering;
en extern funktion med två argument, &MyMod.my_fun/2, den kommer att få paret serie, värde för validering;
modul som implementerar Vela.Validator;
konfigurationsparameter tröskelvärde, och – valfritt – jämför_efter, see chapter Jämförelse under.

Om valideringen lyckas läggs värdet till i listan under motsvarande nyckel, i motsatt fall skickas en tuple {serie, värde} till :__errors_.

Jämförelse

Värdena som lagras i dessa rader kan vara vilka som helst. För att lära Vela dem att jämföra måste du skicka jämför_efter parametern i radens definition (om inte värdena kan jämföras med standard Kernel.</2); denna parameter ska ha typ (Vela.value() -> number()). Som standard är detta bara & &1.

Dessutom kan man i radens definition skicka parameter komparator för att beräkna värdena för deltal.min/max); till exempel kan man genom att skicka Date.diff/2 som komparator få rätt deltal för datum.

Ett annat bekvämt sätt att arbeta är att skicka parameter tröskelvärde, som definierar det maximalt tillåtna förhållandet av det nya värdet till {min, max} intervallet. Eftersom det anges i procent används inte komparator, men används fortfarande jämför_efter. Till exempel, för att ange ett tröskelvärde för tidsstämplar måste du ange jämför_efter: &DateTime.to_unix/1 (för att få ett heltal) och tröskelvärde: 1, vilket gör att nya värden endast tillåts om de ligger inom ±band intervallet från nuvarande värden.

Slutligen kan du använda Vela.equal?/2 jämför/2 , om värden definierar funktionen eller equal?/2jämför/2 ==/2.

, så kommer dessa funktioner att användas för jämförelse, annars använder vi slaviskt

Hämtning av värden Bearbetning av det aktuella tillståndet börjar vanligtvis med att kalla påVela.purge/1 validator , som tar bort föråldrade värden (om kopplade till timestamps). Därför kan man anropa Vela.slice/1, som returnerar keyword med radnamn som nycklar och de aktuella värdena som första värde.

Man kan också använda get_in/2/pop_in/2 för låg nivå åtkomst till värden i varje rad.

Applikation

Vela kan vara extremt användbart som en cache för tidsserier i tillståndet för en process av typen GenServer/Agent. Vi vill aldrig använda föråldrade värden av kurser, och för detta håller vi bara en process med tillstånd behandlat Vela, med en validator som visas nedan.

@impl Vela.Validator
def valid?(_key, %Rate{} = rate),
  do: Rate.age(rate) < @death_age

och Bearbetning av det aktuella tillståndet börjar vanligtvis med att kalla på raderar lugnt alla föråldrade värden varje gång vi behöver data. För att få tillgång till aktuella värden anropar vi bara Vela.slice/1, och när vi behöver en liten historik över kursen (hela raden) returnerar vi helt enkelt den – redan sorterad – med validerade värden.

Lycka till med cachandet av tidsserier!

Källa: habr.com