Graphite 1.1 - Alternative storage finders

वैकल्पिक भंडारण खोजक




graphite

वैकल्पिक भंडारण खोजक

अंतर्निहित खोजक

डिफ़ॉल्ट ग्रेफाइट सेटअप में निम्न शामिल हैं:

  • एक कानाफूसी डेटाबेस
  • डेटाबेस के लिए एक कार्बन डेमन लेखन डेटा
  • डेटाबेस से ग्रेफाइट-वेब रीडिंग और ग्राफिंग डेटा

विशिष्ट आवश्यकताओं को समायोजित करने के लिए, डिफ़ॉल्ट कानाफूसी की तुलना में वैकल्पिक भंडारण परत का उपयोग करना संभव है। ऊपर सेटअप बन जाएगा:

  • एक वैकल्पिक डेटाबेस
  • डेटाबेस में लिखने के लिए एक कार्बन डेमन या वैकल्पिक डेमॉन
  • ग्रेफाइट-वेब में डेटा पढ़ने के लिए एक कस्टम स्टोरेज फाइंडर

इस खंड का उद्देश्य अंतिम आइटम का दस्तावेजीकरण करना है: कस्टम संग्रहण परत से डेटा पढ़ने के लिए ग्रेफाइट-वेब को कॉन्फ़िगर करना।

यह STORAGE_FINDERS सेटिंग के माध्यम से किया जा सकता है। यह सेटिंग खोजक कार्यान्वयन के लिए पथों की एक सूची है। इसका डिफ़ॉल्ट मान है:

STORAGE_FINDERS = (
    'graphite.finders.remote.RemoteFinder',
    'graphite.finders.standard.StandardFinder',
)

डिफ़ॉल्ट खोजक व्हिस्पर डेटाबेस से डेटा पढ़ता है।

प्रयोगात्मक सेरेस डेटाबेस के लिए एक वैकल्पिक खोजक उपलब्ध है:

STORAGE_FINDERS = (
    'graphite.finders.ceres.CeresFinder',
)

सेटिंग कई मानों का समर्थन करती है, जिसका अर्थ है कि आप व्हिस्पर डेटाबेस और सेरेस डेटाबेस दोनों से डेटा पढ़ सकते हैं:

STORAGE_FINDERS = (
    'graphite.finders.remote.RemoteFinder',
    'graphite.finders.standard.StandardFinder',
    'graphite.finders.ceres.CeresFinder',
)

कस्टम खोजक

STORAGE_FINDERS मनमानी अजगर रास्तों की सूची में होने के कारण, कस्टम खोजक लिखना अपेक्षाकृत आसान है यदि आप व्हिस्पर और सेरेस के अलावा अन्य स्थानों से डेटा पढ़ना चाहते हैं। एक खोजक एक अजगर वर्ग है जिसमें एक find_nodes() विधि है:

class CustomFinder(object):
    def find_nodes(self, query):
        # ...

query एक FindQuery वस्तु है। मैट्रिक्स ट्री को ब्राउज़ करते समय find_nodes() प्रविष्टि बिंदु है। इसे क्वेरी से मेल खाते हुए पत्ती या शाखा नोड प्राप्त करना चाहिए:

from graphite.node import LeafNode, BranchNode
from graphite.finders.utils import BaseFinder

class CustomFinder(BaseFinder):
    def find_nodes(self, query):
        # find some paths matching the query, then yield them
        for path in matches:
            if is_branch(path):
                yield BranchNode(path)
            if is_leaf(path):
                yield LeafNode(path, CustomReader(path))

LeafNode एक पाठक के साथ बनाया गया है, जो दिए गए मार्ग के लिए LeafNode प्राप्त करने के लिए जिम्मेदार है। यह एक सरल वर्ग है जिसमें 2 विधियाँ हैं: fetch() और get_intervals() :

from graphite.intervals import IntervalSet, Interval
from graphite.readers.utils import BaseReader

class CustomReader(BaseReader):
    __slots__ = ('path',)  # __slots__ is recommended to save memory on readers

    def __init__(self, path):
        self.path = path

    def fetch(self, start_time, end_time):
        # fetch data
        time_info = _from_, _to_, _step_
        return time_info, series

    def get_intervals(self):
        return IntervalSet([Interval(start, end)])

fetch() में 2 तत्वों की सूची होनी चाहिए: डेटा और स्वयं के डेटा के लिए समय की जानकारी। समय की जानकारी 3 आइटमों की एक सूची है: डेटापॉइंट्स का प्रारंभ समय (यूनिक्स समय में), अंत समय और डेटा स्टेप्स के बीच का समय चरण (सेकंड में)।

डेटापॉइंट आवश्यक अंतराल के लिए डेटाबेस में पाए जाने वाले बिंदुओं की एक सूची है। डेटाबेस में अंतराल होने पर भी (end - start) / step बिंदुओं को डेटासेट में होना चाहिए: अंतराल को None मान से None भरा जा सकता है।

get_intervals() एक विधि है जो डेटाबेस में इस दिए गए मीट्रिक के लिए उपलब्ध समय सीमा के बारे में ग्रेफाइट-वेब को इंगित करता है। इसे एक या एक से अधिक Interval वस्तुओं का IntervalSet लौटना चाहिए।

उन्नत खोजक

कस्टम खोजकर्ता निम्नलिखित विधियों को भी लागू कर सकते हैं:

factory(cls)

यह क्लास विधि सूची के रूप में खोजक ऑब्जेक्ट (ओं) को शुरू करने और वापस करने के लिए जिम्मेदार है।

यह खोजक के 1 या अधिक उदाहरणों की सूची लौटा सकता है, यदि कई उदाहरणों को लौटाया जाता है, तो उन्हें कई धागों में समवर्ती कहा जाएगा। इसका उपयोग RemoteFinder द्वारा समानांतर में कई दूरस्थ होस्ट को अनुरोध भेजने के लिए किया जाता है।

यदि परिभाषित नहीं किया गया है, तो खोजक का एक भी उदाहरण बिना मापदंडों के साथ आरंभ किया जाएगा।

get_index(self, requestContext)

इस विधि को सभी नोड पथ को वापस करना चाहिए जो खोजक को स्ट्रिंग्स की एक सूची के रूप में पता है।

requestContext एक requestContext है जिसमें localOnly और forwardHeaders कुंजी शामिल हो सकते हैं।

यदि लागू नहीं किया जाता है, तो find_nodes() ** लिए एक प्रश्न के साथ बुलाया जाएगा और लौटे नोड्स के रास्तों की एक सूची वापस आ जाएगी।

find_multi(self, queries)

यह विधि find_node() के समान शब्दार्थ का अनुसरण करती है, लेकिन प्रश्नों की सूची को स्वीकार करती है।

यदि लागू नहीं किया गया है, तो find_nodes() निर्दिष्ट प्रत्येक प्रश्न के लिए कहा जाएगा।

fetch(self, patterns, start_time, end_time, now=None, requestContext=None)

यह विधि रेंडर अनुरोधों के लिए डेटा लोड करने के लिए जिम्मेदार है।

इसमें रिजल्ट डाइक की सूची वापस आनी चाहिए, जिनमें से प्रत्येक में निम्न शामिल हैं:

{
  'pathExpression': '<the pattern that this path matched>',
  'path': 'the.metric.path',
  'name': 'the.metric.path',
  'time_info': (_from_, _to_, _step_),
  'values': [list of values],
}

यदि लागू नहीं किया जाता है, find_multi() को प्रश्नों की सूची के साथ बुलाया जाएगा और प्रत्येक परिणाम पर node.fetch() को बुलाया जाएगा।

auto_complete_tags(self, exprs, tagPrefix=None, limit=None, requestContext=None)

इस पद्धति का उपयोग केवल तब किया जाता है जब tags = True वर्ग परिभाषा में tags = True निर्दिष्ट किया जाता है।

यदि इसे परिभाषित किया जाता है तो श्रृंखला के लिए टैग की एक पूरी-पूरी सूची वापस आनी चाहिए जो निर्दिष्ट अभिव्यक्तियों से मेल खाती है।

auto_complete_values(self, exprs, tag, valuePrefix=None, limit=None, requestContext=None)

इस पद्धति का उपयोग केवल तब किया जाता है जब tags = True वर्ग परिभाषा में tags = True निर्दिष्ट किया जाता है।

यदि इसे परिभाषित किया जाता है, तो यह निर्दिष्ट अभिव्यक्तियों से मेल खाने वाली श्रृंखला पर निर्दिष्ट टैग के लिए मानों की एक पूरी-पूरी सूची वापस करना चाहिए।

कस्टम खोजकर्ता स्थापित करना

आपके कस्टम खोजक को आयात करने योग्य बनाने के लिए, आपको उसे अपनी पसंद के नामस्थान के तहत पैकेज करना होगा। पायथन पैकेजिंग को यहां कवर नहीं किया जाएगा, लेकिन आप कुछ प्रेरणा पाने के लिए तीसरे पक्ष के खोजकर्ताओं को देख सकते हैं: