コード例 #1
0
ファイル: node_stats.py プロジェクト: DavidAlphaFox/couchbase
 def run(self, accessor, scale, threshold=None):
     result = {}
     for node, values in stats_buffer.nodes.iteritems():
         if values["status"] != "healthy":
             continue
         if values["StorageInfo"].has_key("hdd"):
             result[node] = {
                        "ip": values["host"],
                        "port": values["port"],
                        "type" : "hdd",
                        "free": util.size_label(values["StorageInfo"]["hdd"]["free"]),
                        "quotaTotal" : util.size_label(values["StorageInfo"]["hdd"]["quotaTotal"]),
                        "used" : util.size_label(values["StorageInfo"]["hdd"]["used"]),
                        "usedByData" : util.size_label(values["StorageInfo"]["hdd"]["usedByData"]),
                        "total" : util.size_label(values["StorageInfo"]["hdd"]["total"])}
         if values["StorageInfo"].has_key("ram"):
             result[node] = {
                        "ip": values["host"],
                        "port": values["port"],
                        "type" : "ram",
                        "quotaTotal" : util.size_label(values["StorageInfo"]["ram"]["quotaTotal"]),
                        "used" : util.size_label(values["StorageInfo"]["ram"]["used"]),
                        "usedByData" : util.size_label(values["StorageInfo"]["ram"]["usedByData"]),
                        "total" : util.size_label(values["StorageInfo"]["ram"]["total"])}
     return result
コード例 #2
0
ファイル: node_stats.py プロジェクト: Crowdpark/couchbase-cli
    def run(self, accessor):
        result = []
        for node, values in stats_buffer.nodes.iteritems():
            result.append({"ip": values["host"],
                           "port": values["port"],
                           "cpuUtilization" :util.pretty_float(values["systemStats"]["cpu_utilization_rate"]),
                           "swapTotal": util.size_label(values["systemStats"]["swap_total"]),
                           "swapUsed" : util.size_label(values["systemStats"]["swap_used"]),
                           "currentItems" : values["systemStats"]["currentItems"],
                           "currentItemsTotal" : values["systemStats"]["currentItemsTotal"],
                           "replicaCurrentItems" : values["systemStats"]["replicaCurrentItems"]})

        return result
コード例 #3
0
ファイル: node_stats.py プロジェクト: DavidAlphaFox/couchbase
    def run(self, accessor, scale, threshold=None):
        result = {}
        for node, values in stats_buffer.nodes.iteritems():
            if values["status"] != "healthy":
                continue
            result[node] = {
                    "ip": values["host"],
                    "port": values["port"],
                    "cpuUtilization" :util.pretty_float(values["systemStats"]["cpu_utilization_rate"]),
                    "swapTotal": util.size_label(values["systemStats"]["swap_total"]),
                    "swapUsed" : util.size_label(values["systemStats"]["swap_used"]),
                    "currentItems" : values["systemStats"]["currentItems"],
                    "currentItemsTotal" : values["systemStats"]["currentItemsTotal"],
                    "replicaCurrentItems" : values["systemStats"]["replicaCurrentItems"]}

        return result
コード例 #4
0
    def run(self, accessor, threshold=None):
        result = {}
        if threshold.has_key("MemoryFragmentation"):
            threshold_val = threshold["MemoryFragmentation"][accessor["name"]]
        else:
            threshold_val = accessor["threshold"]
        for bucket, bucket_stats in stats_buffer.node_stats.iteritems():
            num_error = []
            for node, stats_info in bucket_stats.iteritems():
                for key, value in stats_info.iteritems():
                    if key.find(accessor["counter"]) >= 0:
                        if accessor.has_key("threshold"):
                            if int(value) > threshold_val:
                                if accessor.has_key("unit"):
                                    if accessor["unit"] == "time":
                                        symptom = accessor["symptom"].format(util.time_label(value), util.time_label(threshold_val))
                                        num_error.append({"node":node, "value": symptom})
                                    elif accessor["unit"] == "size":
                                        symptom = accessor["symptom"].format(util.size_label(value), util.size_label(threshold_val))
                                        num_error.append({"node":node, "value": symptom})
                                    else:
                                        symptom = accessor["symptom"].format(value, threshold_val)
                                        num_error.append({"node":node, "value": symptom})
                                else:
                                    symptom = accessor["symptom"].format(value, threshold_val)
                                    num_error.append({"node":node, "value": symptom})

            if len(num_error) > 0:
                result[bucket] = {"error" : num_error}
        return result
コード例 #5
0
ファイル: node_stats.py プロジェクト: DavidAlphaFox/couchbase
 def run(self, accessor, scale, threshold=None):
     result = {}
     if threshold.has_key(accessor["name"]):
         threshold_val = threshold[accessor["name"]]
     elif accessor.has_key("threshold"):
         threshold_val = accessor["threshold"]
     else:
         threshold_val = None
     for bucket, bucket_stats in stats_buffer.node_stats.iteritems():
         stats = []
         for node, stats_info in bucket_stats.iteritems():
             if accessor["counter"] not in stats_info.keys():
                 stats.append((node, "N/A"))
                 continue
             for key, value in stats_info.iteritems():
                 if isinstance(value, dict):
                     continue
                 if key.find(accessor["counter"]) >= 0:
                     if accessor.has_key("threshold"):
                         if int(value) > threshold_val:
                             stats.append((node, (key, value)))
                     else:
                         if accessor.has_key("unit"):
                             if accessor["unit"] == "time":
                                 stats.append((node, util.time_label(value)))
                             elif accessor["unit"] == "size":
                                 stats.append((node, util.size_label(int(value))))
                         else:
                             stats.append((node, (key,value)))
         result[bucket] = stats
     return result
コード例 #6
0
ファイル: node_stats.py プロジェクト: DavidAlphaFox/couchbase
 def run(self, accessor, scale, threshold=None):
     result = {}
     for bucket, stats_info in stats_buffer.buckets.iteritems():
         values = stats_info[scale][accessor["counter"]]
         timestamps = values["timestamp"]
         timestamps = [x - timestamps[0] for x in timestamps]
         nodeStats = values["nodeStats"]
         for node, vals in nodeStats.iteritems():
             if len(vals):
                 avg = vals[-1]
             else:
                 avg = 0
             if accessor.has_key("unit"):
                 if accessor["unit"] == "size":
                     avg = util.size_label(avg)
                 elif accessor["unit"] == "number":
                     avg = util.number_label(avg)
                 elif accessor["unit"] == "time":
                     avg = util.time_label(avg)
                 else:
                     avg = util.pretty_float(avg)
             if result.has_key(node):
                 result[node].append((bucket, avg))
             else:
                 result[node] = [(bucket, avg)]
     return result
コード例 #7
0
 def run(self, accessor):
     result = []
     total = 0
     for node, nodeinfo in stats_buffer.nodes.iteritems():
         if nodeinfo["StorageInfo"].has_key("hdd"):
             total += nodeinfo['StorageInfo']['hdd']['free']
     result.append(util.size_label(total))
     return result
コード例 #8
0
 def run(self, accessor, threshold=None):
     total = 0
     for node, nodeinfo in stats_buffer.nodes.iteritems():
         if nodeinfo["status"] != "healthy":
             continue
         if nodeinfo["StorageInfo"].has_key("hdd"):
             total += nodeinfo['StorageInfo']['hdd']['usedByData']
     return util.size_label(total)
コード例 #9
0
ファイル: node_stats.py プロジェクト: DavidAlphaFox/couchbase
    def run(self, accessor, scale, threshold=None):
        result = {}
        sizing = {}
        if threshold.has_key(accessor["name"]):
            threshold_val = threshold[accessor["name"]]
        elif accessor.has_key("threshold"):
            threshold_val = accessor["threshold"]
        else:
            threshold_val = None
        for bucket, bucket_stats in stats_buffer.node_stats.iteritems():
            stats = []
            for node, stats_info in bucket_stats.iteritems():
                if not sizing.has_key(node):
                    sizing[node] = []
                if accessor["counter"][0] not in stats_info.keys():
                    stats.append((node, "N/A"))
                    sizing[node].append((bucket, "N/A"))
                    continue
                for key, value in stats_info.iteritems():
                    if isinstance(value, dict):
                        continue
                    if key.find(accessor["counter"][0]) >= 0:
                        if accessor["counter"][1] in stats_info and \
                            accessor["counter"][2] in stats_info:
                            total_item_resident = int(stats_info[accessor["counter"][1]]) -\
                                                  int(stats_info[accessor["counter"][2]])
                            if total_item_resident:
                                value = float(value) / total_item_resident
                            else:
                                value = 0

                        if accessor.has_key("unit"):
                            if accessor["unit"] == "time":
                                stats.append((node, util.time_label(value)))
                                sizing[node].append((bucket, util.time_label(value)))
                            elif accessor["unit"] == "size":
                                stats.append((node, util.size_label(int(value))))
                                sizing[node].append((bucket, util.size_label(int(value))))
                        else:
                            stats.append((node, (key,value)))
            result[bucket] = stats
        result["_sizing"] = sizing
        return result
コード例 #10
0
ファイル: node_stats.py プロジェクト: zgolus/couchbase-cli
 def run(self, accessor):
     result = []
     for node, values in stats_buffer.nodes.iteritems():
         if values["StorageInfo"].has_key("hdd"):
             result.append({
                 "ip":
                 values["host"],
                 "port":
                 values["port"],
                 "type":
                 "hdd",
                 "free":
                 util.size_label(values["StorageInfo"]["hdd"]["free"]),
                 "quotaTotal":
                 util.size_label(
                     values["StorageInfo"]["hdd"]["quotaTotal"]),
                 "used":
                 util.size_label(values["StorageInfo"]["hdd"]["used"]),
                 "usedByData":
                 util.size_label(
                     values["StorageInfo"]["hdd"]["usedByData"]),
                 "total":
                 util.size_label(values["StorageInfo"]["hdd"]["total"])
             })
         if values["StorageInfo"].has_key("ram"):
             result.append({
                 "ip":
                 values["host"],
                 "port":
                 values["port"],
                 "type":
                 "ram",
                 "quotaTotal":
                 util.size_label(
                     values["StorageInfo"]["ram"]["quotaTotal"]),
                 "used":
                 util.size_label(values["StorageInfo"]["ram"]["used"]),
                 "usedByData":
                 util.size_label(
                     values["StorageInfo"]["ram"]["usedByData"]),
                 "total":
                 util.size_label(values["StorageInfo"]["ram"]["total"])
             })
     return result
コード例 #11
0
ファイル: node_stats.py プロジェクト: zgolus/couchbase-cli
    def run(self, accessor):
        result = []
        for node, values in stats_buffer.nodes.iteritems():
            result.append({
                "ip":
                values["host"],
                "port":
                values["port"],
                "cpuUtilization":
                util.pretty_float(
                    values["systemStats"]["cpu_utilization_rate"]),
                "swapTotal":
                util.size_label(values["systemStats"]["swap_total"]),
                "swapUsed":
                util.size_label(values["systemStats"]["swap_used"]),
                "currentItems":
                values["systemStats"]["currentItems"],
                "currentItemsTotal":
                values["systemStats"]["currentItemsTotal"],
                "replicaCurrentItems":
                values["systemStats"]["replicaCurrentItems"]
            })

        return result
コード例 #12
0
ファイル: node_stats.py プロジェクト: Crowdpark/couchbase-cli
 def run(self, accessor):
     result = []
     for node, values in stats_buffer.nodes.iteritems():
         if values["StorageInfo"].has_key("hdd"):
             result.append({"ip": values["host"],
                        "port": values["port"],
                        "type" : "hdd",
                        "free": util.size_label(values["StorageInfo"]["hdd"]["free"]),
                        "quotaTotal" : util.size_label(values["StorageInfo"]["hdd"]["quotaTotal"]),
                        "used" : util.size_label(values["StorageInfo"]["hdd"]["used"]),
                        "usedByData" : util.size_label(values["StorageInfo"]["hdd"]["usedByData"]),
                        "total" : util.size_label(values["StorageInfo"]["hdd"]["total"])})
         if values["StorageInfo"].has_key("ram"):
             result.append({"ip": values["host"],
                        "port": values["port"],
                        "type" : "ram",
                        "quotaTotal" : util.size_label(values["StorageInfo"]["ram"]["quotaTotal"]),
                        "used" : util.size_label(values["StorageInfo"]["ram"]["used"]),
                        "usedByData" : util.size_label(values["StorageInfo"]["ram"]["usedByData"]),
                        "total" : util.size_label(values["StorageInfo"]["ram"]["total"])})
     return result
コード例 #13
0
ファイル: node_stats.py プロジェクト: DavidAlphaFox/couchbase
 def run(self, accessor, scale, threshold=None):
     result = {}
     for node, values in stats_buffer.nodes.iteritems():
         if values["status"] != "healthy":
             continue
         val = None
         if isinstance(accessor["counter"], list):
             val = values[accessor["countergroup"]][accessor["counter"][0]] - values[accessor["countergroup"]][accessor["counter"][1]]
         else:
             if accessor.has_key("suffix"):
                 val = values[accessor["countergroup"]][accessor["counter"]][accessor["suffix"]]
             else:
                 val = values[accessor["countergroup"]][accessor["counter"]]
         if val:
             result[node] = val
             if accessor.has_key("unit"):
                 if accessor["unit"] == "size":
                     result[node] = util.size_label(val)
     return result
コード例 #14
0
 def run(self, accessor):
     result = {}
     cluster = 0
     for bucket, stats_info in stats_buffer.buckets.iteritems():
         values = stats_info[accessor["scale"]][accessor["counter"]]
         timestamps = values["timestamp"]
         timestamps = [x - timestamps[0] for x in timestamps]
         nodeStats = values["nodeStats"]
         samplesCount = values["samplesCount"]
         trend = []
         total = 0
         data = []
         for node, vals in nodeStats.iteritems():
             avg = sum(vals) / samplesCount
             trend.append((node, util.size_label(avg)))
             data.append(avg)
         #print data
         trend.append(("variance", util.two_pass_variance(data)))
         result[bucket] = trend
     return result
コード例 #15
0
ファイル: node_stats.py プロジェクト: Crowdpark/couchbase-cli
    def run(self, accessor):
        result = {}
        for bucket, bucket_stats in stats_buffer.node_stats.iteritems():
            stats = []
            for node, stats_info in bucket_stats.iteritems():

                for key, value in stats_info.iteritems():
                    if key.find(accessor["counter"]) >= 0:
                        if accessor.has_key("threshold"):
                            if int(value) > accessor["threshold"]:
                                stats.append((node, (key, value)))
                        else:
                            if accessor.has_key("unit"):
                                if accessor["unit"] == "time":
                                    stats.append((node, util.time_label(value)))
                                elif accessor["unit"] == "size":
                                    stats.append((node, util.size_label(int(value))))
                            else:
                                stats.append((node, (key,value)))

            result[bucket] = stats
        return result
コード例 #16
0
ファイル: node_stats.py プロジェクト: zgolus/couchbase-cli
    def run(self, accessor):
        result = {}
        for bucket, bucket_stats in stats_buffer.node_stats.iteritems():
            stats = []
            for node, stats_info in bucket_stats.iteritems():

                for key, value in stats_info.iteritems():
                    if key.find(accessor["counter"]) >= 0:
                        if accessor.has_key("threshold"):
                            if int(value) > accessor["threshold"]:
                                stats.append((node, (key, value)))
                        else:
                            if accessor.has_key("unit"):
                                if accessor["unit"] == "time":
                                    stats.append(
                                        (node, util.time_label(value)))
                                elif accessor["unit"] == "size":
                                    stats.append(
                                        (node, util.size_label(int(value))))
                            else:
                                stats.append((node, (key, value)))

            result[bucket] = stats
        return result
コード例 #17
0
    def run(self, accessor, scale, threshold=None):
        result = {}
        thresholdval = accessor["threshold"]
        if threshold.has_key("PerformanceDiagnosis_diskread"):
            thresholdval = threshold["PerformanceDiagnosis_diskread"]

        for bucket, stats_info in stats_buffer.buckets.iteritems():
            if stats_info[scale].get(accessor["counter"][0], None) is None:
                return result

            diskRead_values = stats_info[scale][accessor["counter"][0]]
            cacheMissRate_values = stats_info[scale][accessor["counter"][1]]
            arr_values = stats_info[scale][accessor["counter"][2]]
            memUsed_values = stats_info[scale][accessor["counter"][3]]
            curr_values = stats_info[scale][accessor["counter"][4]]
            cmdSet_values = stats_info[scale][accessor["counter"][5]]

            timestamps = diskRead_values["timestamp"]
            samplesCount = diskRead_values["samplesCount"]

            trend = []
            num_warn = []
            for node, vals in diskRead_values["nodeStats"].iteritems():
                diskRead_vals = diskRead_values["nodeStats"][node]
                cacheMissRate_vals = cacheMissRate_values["nodeStats"][node]
                arr_vals = arr_values["nodeStats"][node]
                memUsed_vals = memUsed_values["nodeStats"][node]
                curr_vals = curr_values["nodeStats"][node]
                cmdSet_vals = cmdSet_values["nodeStats"][node]
                if samplesCount > 0:
                    node_avg_mem = sum(memUsed_vals) / samplesCount
                    node_avg_curr = sum(curr_vals) / samplesCount
                    node_avg_cmdset = sum(cmdSet_vals) / samplesCount
                else:
                    node_avg_curr = 0
                # Fine grained analysis
                abnormal_segs = util.abnormal_extract(diskRead_vals, thresholdval["ep_bg_fetched"])
                abnormal_vals = []
                for seg in abnormal_segs:
                    begin_index = seg[0]
                    seg_total = seg[1]
                    if seg_total < thresholdval["recurrence"]:
                        continue
                    end_index = begin_index + seg_total

                    diskread_avg = sum(diskRead_vals[begin_index : end_index]) / seg_total
                    cmr_avg = sum(cacheMissRate_vals[begin_index : end_index]) / seg_total
                    arr_avg = sum(arr_vals[begin_index : end_index]) / seg_total
                    mem_avg = sum(memUsed_vals[begin_index : end_index]) / seg_total
                    curr_avg = sum(curr_vals[begin_index : end_index]) / seg_total
                    cmdSet_avg = sum(cmdSet_vals[begin_index : end_index]) / seg_total

                    if cmr_avg > thresholdval["ep_cache_miss_rate"] and \
                       arr_avg < thresholdval["vb_active_resident_items_ratio"] and \
                       mem_avg > node_avg_mem and \
                       curr_avg > node_avg_curr and \
                       cmdSet_avg > node_avg_cmdset:
                        symptom = accessor["symptom"] % (util.pretty_datetime(timestamps[begin_index]), 
                                                             util.pretty_datetime(timestamps[end_index-1]),
                                                             util.number_label(int(curr_avg)),
                                                             util.size_label(int(mem_avg)),
                                                             util.pretty_float(cmr_avg), 
                                                             util.pretty_float(arr_avg),
                                                             util.number_label(int(diskread_avg)))
                        num_warn.append({"node":node, "value":symptom})
                        abnormal_vals.append(diskread_avg)
                if len(abnormal_vals) > 0:
                    trend.append((node, {"value" : util.pretty_float(sum(abnormal_vals)/len(abnormal_vals)),
                                         "raw" : abnormal_vals}
                                    ))
            if len(num_warn) > 0:
                trend.append(("warn", num_warn))
            result[bucket] = trend

        return result
コード例 #18
0
 def run(self, accessor):
     result = {}
     for bucket, bucket_stats in stats_buffer.node_stats.iteritems():
         num_error = []
         for node, stats_info in bucket_stats.iteritems():
             for key, value in stats_info.iteritems():
                 if key.find(accessor["counter"]) >= 0:
                     if accessor.has_key("threshold"):
                         if int(value) > accessor["threshold"]:
                             if accessor.has_key("unit"):
                                 if accessor["unit"] == "time":
                                     num_error.append({"node":node, "value": (key, util.time_label(value))})
                                 elif accessor["unit"] == "size":
                                     num_error.append({"node":node, "value": (key, util.size_label(value))})
                                 else:
                                     num_error.append({"node":node, "value": (key, value)})
                             else:
                                 num_error.append({"node":node, "value": (key, value)})
         if len(num_error) > 0:
             result[bucket] = {"error" : num_error}
     return result