ProHoster > Blog > Administratioun > Vela → Smart Cache fir Zäitserie a méi

Vela → Smart Cache fir Zäitserie a méi

Am Fintech musse mir dacks zimlech massiv Bänn vu Währungskursdaten veraarbechten. Mir kréien Daten aus verschiddene Quellen, a jidderee vun hinnen huet seng eege Iddi wéi Dir Wechselkursen fir muer, iwwermuer, nächste Mount a souguer déi nächst dräi Joer extrapoléiere kënnt. Wann nëmmen een Tariffer virauszesoen richteg, et wier Zäit d'Geschäft zouzemaachen an einfach domm Suen hin an hier z'änneren. E puer Quelle si méi zouverlässeg, e puer liwweren komplett Müll, mat rare Inklusiounen vu bal korrekte Wäerter, awer fir exotesch Koppelen. Eis Aarbecht ass dës Zéngdausende vu Wäerter pro Sekonn duerchzeféieren an ze bestëmmen wat genau de Clienten ze weisen. Mir mussen deen eenzege richtege Wäert aus Tonnen Dreck a Schläim filteren, sou wéi d'Flamingoen am Mëttegiessen maachen.

Vela → Smart Cache fir Zäitserie a méi

Besonnesch ënnerscheedend Feature vu Flamingoen ass hire massiven no ënnen gebogene Schnéi, mat deem se Liewensmëttel aus Waasser oder Bulli filteren.
 - Wiki

Sou ass d'Bibliothéik gebuer Vela, deen e Staatscache fir verschidde Wäerter mat spezifizéierte Zäitintervalle späichert. Ënnert der Hood filtert et schlecht an al Donnéeën op der Flucht, a bitt och Zougang zu de leschten N validéiert Wäerter fir all Schlëssel (Währungspaar, an eisem Fall).

Loosst eis soen datt mir Tariffer fir dräi Währungspaar sammelen. Déi einfachst Definitioun Vela fir den aktuellen Zoustand ze späicheren wäert et sou ausgesinn: 

defmodule Pairs do
  use Vela,
    eurusd: [sorter: &Kernel.<=/2],
    eurgbp: [limit: 3, errors: 1],
    eurcad: [validator: Pairs]

  @behaviour Vela.Validator

  @impl Vela.Validator
  def valid?(:eurcad, rate), do: rate > 0
end

Aktualiséierung Wäerter

Vela.put/3 D'Funktioun wäert déi folgend an der Sequenz maachen:

  • wäert féieren validator op de Wäert, wann een definéiert ass (kuckt Kapitel Validatioun drënner);
  • wäert de Wäert entweder op d'Zeil vu gudde Wäerter addéieren wann d'Validatioun erfollegräich war, oder op d'Servicerei :__errors__ soss;
  • wäert Ursaach Zortéieren wann sorter definéiert fir e bestëmmte Schlëssel, oder setzt de Wäert einfach un der Spëtzt vun der Lëscht (LIFO, kuckt Kapitel Zortéieren drënner);
  • wäert d'Zeil no dem Parameter trimmen :limit op Kreatioun iwwerginn;
  • wäert déi aktualiséiert Struktur zréckginn Vela.

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

Och Vela ëmsetzt Access, sou datt Dir eng vun de Standardfunktiounen benotze kënnt fir déif Aktualiséierung vun Strukturen aus dem Arsenal fir Wäerter ze aktualiséieren Kernel: Kernel.get_in/2, Kernel.put_in/3, Kernel.update_in/3, Kernel.pop_in/2, an Kernel.get_and_update_in/3.

Validatioun

E Valideur kann definéiert ginn wéi:

  • extern Funktioun mat engem Argument (&MyMod.my_fun/1), et kritt nëmmen de Wäert fir d'Validatioun;
  • extern Funktioun mat zwee Argumenter, &MyMod.my_fun/2, si wäert eng Pair kréien serie, value fir Validatioun;
  • Modul Ëmsetzung Vela.Validator;
  • Konfiguratiounsparameter threshold, an - optional - compare_by, kuckt Kapitel Verglach drënner.

Wann d'Validatioun erfollegräich ass, gëtt de Wäert op d'Lëscht ënner dem entspriechende Schlëssel bäigefüügt {serie, value} geet op :__errors_.

Verglach

D'Wäerter, déi an dëse Reihen gespäichert sinn, kënnen alles sinn. Bäibréngen Vela fir se ze vergläichen, ass et néideg ze transferéieren compare_by Parameter an der Seriedefinitioun (ausser d'Wäerter kënnen net mam Standard verglach ginn Kernel.</2); dëse Parameter muss vun Typ sinn (Vela.value() -> number()). Par défaut ass et einfach & &1.

Och kënnt Dir e Parameter un d'Reidefinitioun passéieren comparator fir Delta Wäerter ze berechnen (min/max); zum Beispill, duerch Iwwerdroung Date.diff/2 als Comparator kënnt Dir déi richteg Deltas fir Datumen kréien.

En anere praktesche Wee fir ze schaffen ass e Parameter ze passéieren threshold, déi definéiert déi maximal zulässlech Verhältnis vun der neier Wäert ze {min, max} Intervall. Well et als Prozentsaz uginn ass, benotzt de Scheck net comparatorawer nach benotzt compare_by. Zum Beispill, fir e Schwellwäert fir Datumzäiten ze spezifizéieren, musst Dir uginn compare_by: &DateTime.to_unix/1 (fir en ganzt Zuelwäert ze kréien) an threshold: 1, verursaacht datt nei Wäerter nëmme erlaabt sinn wa se era sinn ±band Intervall vun den aktuellen Wäerter.

Endlech kënnt Dir benotzen Vela.equal?/2 zwee Cache ze vergläichen. Wann d'Wäerter eng Funktioun definéieren equal?/2 oder compare/2, da ginn dës Funktiounen zum Verglach benotzt, soss benotze mir domm ==/2.

Wäerter ze kréien

D'Veraarbechtung vum aktuellen Zoustand fänkt normalerweis mam Uruff un Vela.purge/1, déi verouderte Wäerter läscht (wann validator ugeschloss timestamps). Dir kënnt dann uruffen Vela.slice/1déi wäert zréck keyword mat Rei Nimm als Schlësselen an déi éischt, tatsächlech Wäerter.

Dir kënnt och benotzen get_in/2/pop_in/2 fir nidderegen Niveau Zougang zu de Wäerter an all Zeil.

Applikatioun

Vela kann extrem nëtzlech sinn als Zäitserie Cache an engem Prozesszoustand wéi GenServer/Agent. Mir wëllen ni verréckt Course Wäerter benotzen, a fir dëst ze maachen halen mir einfach de Prozess mat Staat veraarbecht Vela, mam Validator hei ënnendrënner.

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

и Vela.purge/1 läscht roueg all onbestänneg Wäerter all Kéier wann mir d'Donnéeën brauchen. Fir Zougang zu den aktuellen Wäerter ze kréien, ruffe mir einfach Vela.slice/1, a wann eng kleng Geschicht vum Cours erfuerderlech ass (déi ganz Serie), gi mir se einfach zréck - scho sortéiert - mat validéierte Wäerter.

Glécklech Zäitserie Caching!

Source: will.com

Setzt e Commentaire