Munin contributed plugins

# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

# DEALINGS IN THE SOFTWARE.

#

#

# [solr_*]

#

#

#    ln -s /usr/share/munin/plugins/solr_.py /etc/munin/plugins/solr_numdocs_core_1

#    ln -s /usr/share/munin/plugins/solr_.py /etc/munin/plugins/solr_requesttimes_select

#

import sys

import os

        data = params['core'].rsplit('_', 1)

        handler = data.pop()

        params['params'] = {

        }

        if not data:

            params['core'] = ''

class JSONReader:

    @classmethod

        if not path[0] in struct:

            return -1

        obj = struct[path[0]]

            return -1

        for k in path[1:]:

            obj = obj[k]

        return obj

class SolrCoresAdmin:

        self.host = host

        self.data = None

    def fetchcores(self):

        conn = httplib.HTTPConnection(self.host)

        conn.request("GET", uri)

        res = conn.getresponse()

            return ret

class SolrCoreMBean:

        self.host = host

        self.data = None

        self.core = core

    def _fetch(self):

        conn = httplib.HTTPConnection(self.host)

        conn.request("GET", uri)

        res = conn.getresponse()

                data[key] = el

            else:

                key = el

        if self.data is None:

            self._fetch()

    def _readCache(self, cache):

        result = {}

            path = ['solr-mbeans', 'CACHE', cache, 'stats', 'cumulative_%s' % key]

        return result

    def getCore(self):

        return self.core

    def qps(self, handler):

        path = ['solr-mbeans', 'QUERYHANDLER', handler, 'stats', 'avgRequestsPerSecond']

    def requesttimes(self, handler):

        times = {}

        path = ['solr-mbeans', 'QUERYHANDLER', handler, 'stats']

        for perc in ['avgTimePerRequest', '75thPcRequestTime', '99thPcRequestTime']:

        return times

    def numdocs(self):

        path = ['solr-mbeans', 'CORE', 'searcher', 'stats', 'numDocs']

    def documentcache(self):

        return self._readCache('documentCache')

    def queryresultcache(self):

        return self._readCache('queryResultCache')

#############################################################################

# Graph Templates

"""

graph_vlabel request / second

graph_category solr

{cores_qps_graphs}"""

QPSCORE_GRAPH_TPL = """qps_{core}.label {core} Request per second

qps_{core}.graph yes"""

REQUESTTIMES_GRAPH_TPL = """multigraph {core}_requesttimes

graph_vlabel millis

graph_category solr

savgtimeperrequest_{core}.label {core} Avg time per request

savgtimeperrequest_{core}.graph yes

s75thpcrequesttime_{core}.label {core} 75th perc

s75thpcrequesttime_{core}.graph yes

s99thpcrequesttime_{core}.label {core} 99th perc

s99thpcrequesttime_{core}.graph yes

"""

NUMDOCS_GRAPH_TPL = """graph_title Solr Docs %s

docs.label Docs

graph_category solr"""

graph_vlabel Bytes

graph_title Index Size

graph_category solr

graph_order {cores}

{cores_config}

"""

INDEXSIZECORE_GRAPH_TPL = """{core}.label {core}

{core}.draw STACK""" 

#############################################################################

# Graph managment

class SolrMuninGraph:

        self.hostport = hostport

        self.params = params

    def _getMBean(self, core):

    def _cacheConfig(self, cacheType, cacheName):

        return CACHE_GRAPH_TPL.format(core=self.params['core'], cacheType=cacheType, cacheName=cacheName)

        data = getattr(solrmbean, cacheType)()

        results.append('multigraph solr_{core}_{cacheType}_hit_rates'.format(core=self.params['core'], cacheType=cacheType))

        for label in hits_fields:

        results.append('multigraph solr_{core}_{cacheType}_size'.format(core=self.params['core'], cacheType=cacheType))

        for label in size_fields:

        return "\n".join(results)

    def config(self, mtype):

            raise CheckException("Unknown check %s" % mtype)

        return getattr(self, '%sConfig' % mtype)()

    def qpsConfig(self):

        cores = self._getCores()

        return QPSMAIN_GRAPH_TPL.format(

            cores_qps_graphs='\n'.join(graph), 

            handler=self.params['params']['handler'], 

            core=self.params['core'], 

        )

    def qps(self):

        cores = self._getCores()

        for c in cores:

            mbean = self._getMBean(c)

        return '\n'.join(results)

    def requesttimesConfig(self):

            mbean = self._getMBean(c)

            results.append('multigraph {core}_requesttimes'.format(core=c))

            for k, time in mbean.requesttimes(self.params['params']['handler']).items():

        return '\n'.join(results)

    def numdocsConfig(self):

    def numdocs(self):

        mbean = self._getMBean(self.params['core'])

    def indexsizeConfig(self):

        cores = self._getCores()

        graph = [ INDEXSIZECORE_GRAPH_TPL.format(core=c) for c in cores]

    def indexsize(self):

        results = []

        for c, size in self.solrcoresadmin.indexsize(**self.params['params']).items():

        return "\n".join(results)

    def documentcacheConfig(self):

        return self._cacheConfig('documentcache', 'Document Cache')

if __name__ == '__main__':

    params = parse_params()

    SOLR_HOST_PORT = os.environ.get('host_port', 'localhost:8080').replace('http://', '')