वेळ मालिका आणि अधिकसाठी Vela → स्मार्ट कॅशे

फिनटेकमध्ये, आम्हाला बर्‍याचदा मोठ्या प्रमाणावर चलन विनिमय दर डेटावर प्रक्रिया करावी लागते. आम्हाला वेगवेगळ्या स्त्रोतांकडून डेटा मिळतो आणि त्या प्रत्येकाची स्वतःची कल्पना आहे की उद्या, परवा, पुढचा महिना आणि अगदी पुढील तीन वर्षांसाठी दरांची मूल्ये कशी एक्स्ट्रापोलेट करायची. जर कोणी दरांचा अंदाज लावू शकतो उजवीकडे, व्यवसाय बंद करणे आणि फक्त मूर्खपणाने पैसे परत बदलणे योग्य होईल. काही स्त्रोत अधिक विश्वासार्ह आहेत, काही पूर्णपणे कचरा आहेत, अधूनमधून एकमेकांशी जोडलेल्या जवळ-योग्य मूल्यांसह, परंतु विदेशी जोडप्यांसाठी. आमचे कार्य प्रति सेकंद या दहा हजारो मूल्यांचा शोध घेणे आणि ग्राहकांना नेमके काय दाखवायचे हे ठरवणे हे आहे. फ्लेमिंगो रात्रीच्या जेवणात करतात त्याप्रमाणे आपल्याला एक टन घाण आणि गाळ यातून एकच योग्य मूल्य फिल्टर करावे लागेल.

फ्लेमिंगोचे एक विशेष वैशिष्ट्य म्हणजे खाली-वक्र चोच, ज्याद्वारे ते पाणी किंवा गाळातून अन्न फिल्टर करतात.
 - विकी

अशा प्रकारे ग्रंथालयाचा जन्म झाला. Velaदिलेल्या वेळेच्या अंतराने अनेक मूल्यांसाठी स्टेट कॅशे संचयित करते. हुड अंतर्गत, ते फ्लायवर खराब आणि कालबाह्य डेटा फिल्टर करते आणि नवीनतममध्ये प्रवेश देखील प्रदान करते N प्रत्येक की साठी प्रमाणित मूल्ये (चलन जोडी, आमच्या बाबतीत).

समजा आम्ही तीन जोडी चलनांसाठी दर गोळा करतो. सर्वात सोपी व्याख्या Vela वर्तमान स्थिती संचयित करण्यासाठी असे काहीतरी दिसेल:

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

मूल्ये अद्यतनित करत आहे

Vela.put/3 फंक्शन क्रमाक्रमाने पुढील गोष्टी करेल:

• कारणीभूत होईल validator मूल्यावर, जर एक परिभाषित केले असेल (धडा पहा प्रमाणीकरण खाली);
• प्रमाणीकरण यशस्वी झाल्यास किंवा सेवा मालिकेत एकतर चांगल्या मूल्यांच्या श्रेणीमध्ये मूल्य जोडेल :__errors__ अन्यथा;
• जर वर्गीकरण ट्रिगर करेल sorter दिलेल्या की साठी परिभाषित, किंवा फक्त मूल्य सूचीच्या शीर्षस्थानी ठेवा (निर्जीव, धडा पहा वर्गीकरण खाली);
• पॅरामीटरनुसार पंक्ती कट करेल :limit निर्मितीवर उत्तीर्ण;
• अद्ययावत रचना परत करेल 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]}

तसेच Vela अवजारे Access, त्यामुळे मूल्ये अपडेट करण्यासाठी तुम्ही शस्त्रागारातील संरचना सखोल अद्यतनित करण्यासाठी कोणतेही मानक कार्य वापरू शकता Kernel: Kernel.get_in/2, Kernel.put_in/3, Kernel.update_in/3, Kernel.pop_in/2आणि Kernel.get_and_update_in/3.

प्रमाणीकरण

सत्यापनकर्ता अशी परिभाषित केली जाऊ शकते:

• एका युक्तिवादासह बाह्य कार्य (&MyMod.my_fun/1), त्याला फक्त प्रमाणीकरण मूल्य मिळेल;
• दोन वितर्कांसह बाह्य कार्य, &MyMod.my_fun/2तिला एक जोडपे मिळेल serie, value प्रमाणीकरणासाठी;
• अंमलबजावणी करणारे मॉड्यूल Vela.Validator;
• कॉन्फिगरेशन पॅरामीटर threshold, आणि - वैकल्पिकरित्या - compare_by, धडा पहा तुलना खाली.

प्रमाणीकरण यशस्वी झाल्यास, मूल्य संबंधित की अंतर्गत सूचीमध्ये जोडले जाईल, अन्यथा टपल {serie, value} ला जातो :__errors_.

तुलना

या पंक्तींमध्ये संग्रहित मूल्ये काहीही असू शकतात. शिकवण्यासाठी Vela त्यांची तुलना करण्यासाठी, हस्तांतरित करणे आवश्यक आहे compare_by मालिकेच्या व्याख्येसाठी पॅरामीटर (जोपर्यंत मूल्यांची मानकांशी तुलना केली जाऊ शकत नाही Kernel.</2); हे पॅरामीटर प्रकारचे असणे आवश्यक आहे (Vela.value() -> number()). डीफॉल्टनुसार ते फक्त आहे & &1.

तसेच, तुम्ही पॅरामीटरला पंक्तीच्या व्याख्येमध्ये पास करू शकता comparator डेल्टा मूल्यांची गणना करण्यासाठी (min/max); उदाहरणार्थ, उत्तीर्ण Date.diff/2 तुलनाकर्ता म्हणून, आपण तारखांसाठी योग्य डेल्टा मिळवू शकता.

काम करण्याचा आणखी एक सोयीस्कर मार्ग म्हणजे पॅरामीटर पास करणे threshold, जे नवीन मूल्याचे कमाल स्वीकार्य गुणोत्तर परिभाषित करते {min, max} मध्यांतर टक्केवारी म्हणून दिलेला असल्याने धनादेशाचा उपयोग होत नाही comparatorपण तरीही वापरत आहे compare_by. उदाहरणार्थ, तारखेच्या वेळेसाठी थ्रेशोल्ड मूल्य निर्दिष्ट करण्यासाठी, आपण निर्दिष्ट कराल compare_by: &DateTime.to_unix/1 (पूर्णांक मूल्य मिळविण्यासाठी) आणि threshold: 1, ज्यामुळे नवीन मूल्ये असतील तरच परवानगी दिली जाईल ±band वर्तमान मूल्यांमधून मध्यांतर.

शेवटी, आपण वापरू शकता Vela.equal?/2 दोन कॅशेची तुलना करण्यासाठी. जर मूल्ये फंक्शन परिभाषित करतात equal?/2 किंवा compare/2, नंतर ही कार्ये तुलना करण्यासाठी वापरली जातील, अन्यथा आम्ही मूर्खपणे वापरतो ==/2.

मूल्ये मिळवणे

वर्तमान स्थिती हाताळणे सहसा कॉलने सुरू होते Vela.purge/1, जे अप्रचलित मूल्ये काढून टाकते (जर validator सोबत बांधलेले timestamps). त्यानंतर तुम्ही कॉल करू शकता Vela.slice/1, जे परत येईल keyword की म्हणून पंक्तीच्या नावांसह आणि प्रथम, वास्तविक मूल्यांसह.

तुम्ही देखील वापरू शकता get_in/2/pop_in/2 प्रत्येक पंक्तीमधील मूल्यांच्या निम्न-स्तरीय प्रवेशासाठी.

अनुप्रयोग

Vela सारख्या प्रक्रियेच्या स्थितीत वेळ मालिका कॅशे म्हणून अत्यंत उपयुक्त असू शकते GenServer/Agent. आम्हाला जुनी दर मूल्ये कधीही वापरायची नाहीत आणि ते करण्यासाठी आम्ही फक्त राज्य हाताळलेली प्रक्रिया ठेवतो Vela, खाली दर्शविलेल्या प्रमाणीकरणकर्त्यासह.

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

и Vela.purge/1 प्रत्येक वेळी जेव्हा आम्हाला डेटाची आवश्यकता असते तेव्हा सर्व अप्रचलित मूल्ये शांतपणे काढून टाकते. वास्तविक मूल्यांमध्ये प्रवेश करण्यासाठी, आम्ही फक्त कॉल करतो Vela.slice/1, आणि जेव्हा आम्हाला लहान विनिमय दर इतिहासाची (संपूर्ण मालिका) आवश्यकता असते, तेव्हा आम्ही ते परत करतो - आधीच क्रमवारी लावलेले - प्रमाणित मूल्यांसह.

• GitHub
• हेक्सडॉक्स

आनंदी वेळ मालिका कॅशिंग!

स्त्रोत: www.habr.com