from json import loads

from bases.FrameworkServices.UrlService import UrlService

update_every = 10
disabled_by_default = True



            

Reported by Pylint.

              # -*- coding: utf-8 -*-
# Description: alarms netdata python.d module
# Author: andrewm4894
# SPDX-License-Identifier: GPL-3.0-or-later

from json import loads

from bases.FrameworkServices.UrlService import UrlService


            

Reported by Pylint.

              
from bases.FrameworkServices.UrlService import UrlService

update_every = 10
disabled_by_default = True


def charts_template(sm, alarm_status_chart_type='line'):
    order = [

            

Reported by Pylint.

              from bases.FrameworkServices.UrlService import UrlService

update_every = 10
disabled_by_default = True


def charts_template(sm, alarm_status_chart_type='line'):
    order = [
        'alarms',

            

Reported by Pylint.

              disabled_by_default = True


def charts_template(sm, alarm_status_chart_type='line'):
    order = [
        'alarms',
        'values'
    ]


            

Reported by Pylint.

              disabled_by_default = True


def charts_template(sm, alarm_status_chart_type='line'):
    order = [
        'alarms',
        'values'
    ]


            

Reported by Pylint.

                  mappings = ', '.join(['{0}={1}'.format(k, v) for k, v in sm.items()])
    charts = {
        'alarms': {
            'options': [None, 'Alarms ({0})'.format(mappings), 'status', 'status', 'alarms.status', alarm_status_chart_type],
            'lines': [],
            'variables': [
                ['alarms_num'],
            ]
        },

            

Reported by Pylint.

              DEFAULT_ALARM_STATUS_CHART_TYPE = 'line'


class Service(UrlService):
    def __init__(self, configuration=None, name=None):
        UrlService.__init__(self, configuration=configuration, name=name)
        self.sm = self.configuration.get('status_map', DEFAULT_STATUS_MAP)
        self.alarm_status_chart_type = self.configuration.get('alarm_status_chart_type', DEFAULT_ALARM_STATUS_CHART_TYPE)
        self.order, self.definitions = charts_template(self.sm, self.alarm_status_chart_type)

            

Reported by Pylint.

              DEFAULT_ALARM_STATUS_CHART_TYPE = 'line'


class Service(UrlService):
    def __init__(self, configuration=None, name=None):
        UrlService.__init__(self, configuration=configuration, name=name)
        self.sm = self.configuration.get('status_map', DEFAULT_STATUS_MAP)
        self.alarm_status_chart_type = self.configuration.get('alarm_status_chart_type', DEFAULT_ALARM_STATUS_CHART_TYPE)
        self.order, self.definitions = charts_template(self.sm, self.alarm_status_chart_type)

            

Reported by Pylint.

              class Service(UrlService):
    def __init__(self, configuration=None, name=None):
        UrlService.__init__(self, configuration=configuration, name=name)
        self.sm = self.configuration.get('status_map', DEFAULT_STATUS_MAP)
        self.alarm_status_chart_type = self.configuration.get('alarm_status_chart_type', DEFAULT_ALARM_STATUS_CHART_TYPE)
        self.order, self.definitions = charts_template(self.sm, self.alarm_status_chart_type)
        self.url = self.configuration.get('url', DEFAULT_URL)
        self.collect_alarm_values = bool(self.configuration.get('collect_alarm_values', DEFAULT_COLLECT_ALARM_VALUES))
        self.collected_dims = {'alarms': set(), 'values': set()}

            

Reported by Pylint.

              except ImportError:
    from time import time

from bases.FrameworkServices.SimpleService import SimpleService

PORT_LATENCY = 'connect'

PORT_SUCCESS = 'success'
PORT_TIMEOUT = 'timeout'

            

Reported by Pylint.

              # -*- coding: utf-8 -*-
# Description: simple port check netdata python.d module
# Original Author: ccremer (github.com/ccremer)
# SPDX-License-Identifier: GPL-3.0-or-later

import socket

try:
    from time import monotonic as time

            

Reported by Pylint.

              
CHARTS = {
    'latency': {
        'options': [None, 'TCP connect latency', 'milliseconds', 'latency', 'portcheck.latency', 'line'],
        'lines': [
            [PORT_LATENCY, 'connect', 'absolute', 100, 1000]
        ]
    },
    'status': {

            

Reported by Pylint.

              

# Not deriving from SocketService, too much is different
class Service(SimpleService):
    def __init__(self, configuration=None, name=None):
        SimpleService.__init__(self, configuration=configuration, name=name)
        self.order = ORDER
        self.definitions = CHARTS
        self.host = self.configuration.get('host')

            

Reported by Pylint.

              

# Not deriving from SocketService, too much is different
class Service(SimpleService):
    def __init__(self, configuration=None, name=None):
        SimpleService.__init__(self, configuration=configuration, name=name)
        self.order = ORDER
        self.definitions = CHARTS
        self.host = self.configuration.get('host')

            

Reported by Pylint.

              
    def check(self):
        """
        Parse configuration, check if configuration is available, and dynamically create chart lines data
        :return: boolean
        """
        if self.host is None or self.port is None:
            self.error('Host or port missing')
            return False

            

Reported by Pylint.

                          self.error('"port" is not an integer. Specify a numerical value, not service name.')
            return False

        self.debug('Enabled portcheck: {host}:{port}, update every {update}s, timeout: {timeout}s'.format(
            host=self.host, port=self.port, update=self.update_every, timeout=self.timeout
        ))
        # We will accept any (valid-ish) configuration, even if initial connection fails (a service might be down from
        # the beginning)
        return True

            

Reported by Pylint.

                      self.debug('Enabled portcheck: {host}:{port}, update every {update}s, timeout: {timeout}s'.format(
            host=self.host, port=self.port, update=self.update_every, timeout=self.timeout
        ))
        # We will accept any (valid-ish) configuration, even if initial connection fails (a service might be down from
        # the beginning)
        return True

    def _get_data(self):
        """

            

Reported by Pylint.

              
        success = False
        try:
            for socket_config in socket.getaddrinfo(self.host, self.port, socket.AF_UNSPEC, socket.SOCK_STREAM):
                # use first working socket
                sock = self._create_socket(socket_config)
                if sock is not None:
                    self._connect2socket(data, socket_config, sock)
                    self._disconnect(sock)

            

Reported by Pylint.

                      return data

    def _create_socket(self, socket_config):
        af, sock_type, proto, _, sa = socket_config
        try:
            self.debug('Creating socket to "{address}", port {port}'.format(address=sa[0], port=sa[1]))
            sock = socket.socket(af, sock_type, proto)
            sock.settimeout(self.timeout)
            return sock

            

Reported by Pylint.

              // Gen filename allocation and concatenation
#define GEN_DO_COUNTER_NAME(NAME, GRP, DESC, DIR, PORT, ...)                                                           \
    PORT->file_##NAME = callocz(1, strlen(PORT->counters_path) + sizeof(#NAME) + 3);                                   \
    strcat(PORT->file_##NAME, PORT->counters_path);                                                                    \
    strcat(PORT->file_##NAME, "/" #NAME);
                    FOREACH_COUNTER(GEN_DO_COUNTER_NAME, p)

                    // Check HW Counters vendor dependent
                    DIR *hwcounters_dir = opendir(hwcounters_dirname);

            

Reported by FlawFinder.

              #define GEN_DO_COUNTER_NAME(NAME, GRP, DESC, DIR, PORT, ...)                                                           \
    PORT->file_##NAME = callocz(1, strlen(PORT->counters_path) + sizeof(#NAME) + 3);                                   \
    strcat(PORT->file_##NAME, PORT->counters_path);                                                                    \
    strcat(PORT->file_##NAME, "/" #NAME);
                    FOREACH_COUNTER(GEN_DO_COUNTER_NAME, p)

                    // Check HW Counters vendor dependent
                    DIR *hwcounters_dir = opendir(hwcounters_dirname);
                    if (hwcounters_dir) {

            

Reported by FlawFinder.

              // Allocate the chars to the filenames
#define GEN_DO_HWCOUNTER_NAME(NAME, GRP, DESC, DIR, PORT, HW, ...)                                                     \
    HW->file_##NAME = callocz(1, strlen(PORT->hwcounters_path) + sizeof(#NAME) + 3);                                   \
    strcat(HW->file_##NAME, PORT->hwcounters_path);                                                                    \
    strcat(HW->file_##NAME, "/" #NAME);

                        // VENDOR-MLX: Mellanox
                        if (strncmp(dev_dent->d_name, "mlx", 3) == 0) {
                            // Allocate the vendor specific struct

            

Reported by FlawFinder.

              #define GEN_DO_HWCOUNTER_NAME(NAME, GRP, DESC, DIR, PORT, HW, ...)                                                     \
    HW->file_##NAME = callocz(1, strlen(PORT->hwcounters_path) + sizeof(#NAME) + 3);                                   \
    strcat(HW->file_##NAME, PORT->hwcounters_path);                                                                    \
    strcat(HW->file_##NAME, "/" #NAME);

                        // VENDOR-MLX: Mellanox
                        if (strncmp(dev_dent->d_name, "mlx", 3) == 0) {
                            // Allocate the vendor specific struct
                            p->hwcounters_mlx = callocz(1, sizeof(struct ibporthw_mlx));

            

Reported by FlawFinder.

              {
    struct ibport *p;

    char name[IBNAME_MAX + 1];
    snprintfz(name, IBNAME_MAX, "%s-%s", dev, port);

    // search it, resuming from the last position in sequence
    for (p = ibport_last_used; p; p = p->next) {
        if (unlikely(!strcmp(name, p->name))) {

            

Reported by FlawFinder.

                  p->chart_type_hwpackets = strdupz("infiniband_hwc_packets");
    p->chart_type_hwerrors  = strdupz("infiniband_hwc_errors");

    char buffer[RRD_ID_LENGTH_MAX + 1];
    snprintfz(buffer, RRD_ID_LENGTH_MAX, "ib_cntbytes_%s",     p->name);
    p->chart_id_bytes = strdupz(buffer);

    snprintfz(buffer, RRD_ID_LENGTH_MAX, "ib_cntpackets_%s",   p->name);
    p->chart_id_packets = strdupz(buffer);

            

Reported by FlawFinder.

                  static long long int dt_to_refresh_ports = 0, last_refresh_ports_usec = 0;

    if (unlikely(enable_new_ports == -1)) {
        char dirname[FILENAME_MAX + 1];

        snprintfz(dirname, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/class/infiniband");
        sys_class_infiniband_dirname =
            config_get(CONFIG_SECTION_PLUGIN_SYS_CLASS_INFINIBAND, "dirname to monitor", dirname);


            

Reported by FlawFinder.

                              continue;

            // /sys/class/infiniband/<dev>/ports
            char ports_dirname[FILENAME_MAX + 1];
            snprintfz(ports_dirname, FILENAME_MAX, "%s/%s/%s", sys_class_infiniband_dirname, dev_dent->d_name, "ports");

            DIR *ports_dir = opendir(ports_dirname);
            if (unlikely(!ports_dir))
                continue;

            

Reported by FlawFinder.

                              if (!strcmp(port_dent->d_name, "..") || !strcmp(port_dent->d_name, "."))
                    continue;

                char buffer[FILENAME_MAX + 1];

                // Check if counters are available (mandatory)
                // /sys/class/infiniband/<device>/ports/<port>/counters
                char counters_dirname[FILENAME_MAX + 1];
                snprintfz(counters_dirname, FILENAME_MAX, "%s/%s/%s", ports_dirname, port_dent->d_name, "counters");

            

Reported by FlawFinder.

              
                // Check if counters are available (mandatory)
                // /sys/class/infiniband/<device>/ports/<port>/counters
                char counters_dirname[FILENAME_MAX + 1];
                snprintfz(counters_dirname, FILENAME_MAX, "%s/%s/%s", ports_dirname, port_dent->d_name, "counters");
                DIR *counters_dir = opendir(counters_dirname);
                // Standard counters are mandatory
                if (!counters_dir)
                    continue;

            

Reported by FlawFinder.

              void set_global_variables()
{
    // Get environment variables
    ebpf_plugin_dir = getenv("NETDATA_PLUGINS_DIR");
    if (!ebpf_plugin_dir)
        ebpf_plugin_dir = PLUGINS_DIR;

    ebpf_user_config_dir = getenv("NETDATA_USER_CONFIG_DIR");
    if (!ebpf_user_config_dir)

            

Reported by FlawFinder.

                  if (!ebpf_plugin_dir)
        ebpf_plugin_dir = PLUGINS_DIR;

    ebpf_user_config_dir = getenv("NETDATA_USER_CONFIG_DIR");
    if (!ebpf_user_config_dir)
        ebpf_user_config_dir = CONFIG_DIR;

    ebpf_stock_config_dir = getenv("NETDATA_STOCK_CONFIG_DIR");
    if (!ebpf_stock_config_dir)

            

Reported by FlawFinder.

                  if (!ebpf_user_config_dir)
        ebpf_user_config_dir = CONFIG_DIR;

    ebpf_stock_config_dir = getenv("NETDATA_STOCK_CONFIG_DIR");
    if (!ebpf_stock_config_dir)
        ebpf_stock_config_dir = LIBCONFIG_DIR;

    ebpf_configured_log_dir = getenv("NETDATA_LOG_DIR");
    if (!ebpf_configured_log_dir)

            

Reported by FlawFinder.

                  if (!ebpf_stock_config_dir)
        ebpf_stock_config_dir = LIBCONFIG_DIR;

    ebpf_configured_log_dir = getenv("NETDATA_LOG_DIR");
    if (!ebpf_configured_log_dir)
        ebpf_configured_log_dir = LOG_DIR;

    ebpf_nprocs = (int)sysconf(_SC_NPROCESSORS_ONLN);
    if (ebpf_nprocs > NETDATA_MAX_PROCESSOR) {

            

Reported by FlawFinder.

                  }

    while (1) {
        int c = getopt_long(argc, argv, "hvgacdnprsw", long_options, &option_index);
        if (c == -1)
            break;

        switch (c) {
            case 'h': {

            

Reported by FlawFinder.

                                                            .rwlock = AVL_LOCK_INITIALIZER } };

int running_on_kernel = 0;
char kernel_string[64];
int ebpf_nprocs;
static int isrh;
uint32_t finalized_threads = 1;

pthread_mutex_t lock;

            

Reported by FlawFinder.

              
        int family = ifa->ifa_addr->sa_family;
        w->ver = (uint8_t) family;
        char text[INET6_ADDRSTRLEN];
        if (family == AF_INET) {
            struct sockaddr_in *in = (struct sockaddr_in*) ifa->ifa_addr;

            w->first.addr32[0] = in->sin_addr.s_addr;
            w->last.addr32[0] = in->sin_addr.s_addr;

            

Reported by FlawFinder.

                      } else {
            struct sockaddr_in6 *in6 = (struct sockaddr_in6*) ifa->ifa_addr;

            memcpy(w->first.addr8, (void *)&in6->sin6_addr, sizeof(struct in6_addr));
            memcpy(w->last.addr8, (void *)&in6->sin6_addr, sizeof(struct in6_addr));

            if (inet_ntop(AF_INET6, w->first.addr8, text, INET_ADDRSTRLEN)) {
                w->value = strdupz(text);
                w->hash = simple_hash(text);

            

Reported by FlawFinder.

                          struct sockaddr_in6 *in6 = (struct sockaddr_in6*) ifa->ifa_addr;

            memcpy(w->first.addr8, (void *)&in6->sin6_addr, sizeof(struct in6_addr));
            memcpy(w->last.addr8, (void *)&in6->sin6_addr, sizeof(struct in6_addr));

            if (inet_ntop(AF_INET6, w->first.addr8, text, INET_ADDRSTRLEN)) {
                w->value = strdupz(text);
                w->hash = simple_hash(text);
            } else {

            

Reported by FlawFinder.

               */
static int load_collector_config(char *path, int *disable_apps)
{
    char lpath[4096];

    snprintf(lpath, 4095, "%s/%s", path, NETDATA_EBPF_CONFIG_FILE);
    if (!appconfig_load(&collector_config, lpath, 0, NULL)) {
        snprintf(lpath, 4095, "%s/%s", path, NETDATA_EBPF_OLD_CONFIG_FILE);
        if (!appconfig_load(&collector_config, lpath, 0, NULL)) {

            

Reported by FlawFinder.

              import re
from copy import deepcopy

from bases.FrameworkServices.SocketService import SocketService

REDIS_ORDER = [
    'operations',
    'hit_rate',
    'memory',

            

Reported by Pylint.

              # -*- coding: utf-8 -*-
# Description: redis netdata python.d module
# Author: Pawel Krupa (paulfantom)
# Author: Ilya Mashchenko (ilyam8)
# SPDX-License-Identifier: GPL-3.0-or-later

import re
from copy import deepcopy


            

Reported by Pylint.

                      ]
    },
    'connections': {
        'options': [None, 'Connections', 'connections/s', 'connections', 'redis.connections', 'line'],
        'lines': [
            ['total_connections_received', 'received', 'incremental', 1],
            ['rejected_connections', 'rejected', 'incremental', -1]
        ]
    },

            

Reported by Pylint.

              }


def copy_chart(name):
    return {name: deepcopy(CHARTS[name])}


RE = re.compile(r'\n([a-z_0-9 ]+):(?:keys=)?([^,\r]+)')


            

Reported by Pylint.

              RE = re.compile(r'\n([a-z_0-9 ]+):(?:keys=)?([^,\r]+)')


class Service(SocketService):
    def __init__(self, configuration=None, name=None):
        SocketService.__init__(self, configuration=configuration, name=name)
        self.order = list()
        self.definitions = dict()
        self._keep_alive = True

            

Reported by Pylint.

              RE = re.compile(r'\n([a-z_0-9 ]+):(?:keys=)?([^,\r]+)')


class Service(SocketService):
    def __init__(self, configuration=None, name=None):
        SocketService.__init__(self, configuration=configuration, name=name)
        self.order = list()
        self.definitions = dict()
        self._keep_alive = True

            

Reported by Pylint.

                      self.host = self.configuration.get('host', 'localhost')
        self.port = self.configuration.get('port', 6379)
        self.unix_socket = self.configuration.get('socket')
        p = self.configuration.get('pass')
        self.auth_request = 'AUTH {0} \r\n'.format(p).encode() if p else None
        self.request = 'INFO\r\n'.encode()
        self.bgsave_time = 0
        self.keyspace_dbs = set()


            

Reported by Pylint.

                      self.bgsave_time = 0
        self.keyspace_dbs = set()

    def do_auth(self):
        resp = self._get_raw_data(request=self.auth_request)
        if not resp:
            return False
        if resp.strip() != '+OK':
            self.error('invalid password')

            

Reported by Pylint.

                          return False
        return True

    def get_raw_and_parse(self):
        if self.auth_request and not self.do_auth():
            return None

        resp = self._get_raw_data()


            

Reported by Pylint.

                      return data

    @staticmethod
    def calc_hit_rate(data):
        try:
            hits = int(data['keyspace_hits'])
            misses = int(data['keyspace_misses'])
            data['hit_rate'] = hits * 100 / (hits + misses)
        except (KeyError, ZeroDivisionError):

            

Reported by Pylint.

                  }

    // find the physical file on disk
    char webfilename[FILENAME_MAX + 1];
    snprintfz(webfilename, FILENAME_MAX, "%s/%s", netdata_configured_web_dir, filename);

    struct stat statbuf;
    int done = 0;
    while(!done) {

            

Reported by FlawFinder.

                  }

    // open the file
    w->ifd = open(webfilename, O_NONBLOCK, O_RDONLY);
    if(w->ifd == -1) {
        w->ifd = w->ofd;

        if(errno == EBUSY || errno == EAGAIN) {
            error("%llu: File '%s' is busy, sending 307 Moved Temporarily to force retry.", w->id, webfilename);

            

Reported by FlawFinder.

                          w->header_parse_last_size = 0;
            web_client_disable_wait_receive(w);

            char hostname[256];
            char *copyme = strstr(s,"hostname=");
            if ( copyme ){
                copyme += 9;
                char *end = strchr(copyme,'&');
                if(end){

            

Reported by FlawFinder.

                              char *end = strchr(copyme,'&');
                if(end){
                    size_t length = MIN(255, end - copyme);
                    memcpy(hostname,copyme,length);
                    hostname[length] = 0X00;
                }
                else{
                    memcpy(hostname,"not available",13);
                    hostname[13] = 0x00;

            

Reported by FlawFinder.

                                  hostname[length] = 0X00;
                }
                else{
                    memcpy(hostname,"not available",13);
                    hostname[13] = 0x00;
                }
            }
            else{
                memcpy(hostname,"not available",13);

            

Reported by FlawFinder.

                              }
            }
            else{
                memcpy(hostname,"not available",13);
                hostname[13] = 0x00;
            }
            error("The server is configured to always use encrypted connections, please enable the SSL on child with hostname '%s'.",hostname);
            s = NULL;
        }

            

Reported by FlawFinder.

              
    //Variables used to map the variables in the query string case it is present
    int total_variables;
    char *ptr_variables[WEB_FIELDS_MAX];

    // make sure we have complete request
    // complete requests contain: \r\n\r\n
    while(*s) {
        // find a line feed

            

Reported by FlawFinder.

                  const char *code_msg = web_response_code_to_string(w->response.code);

    // prepare the last modified and expiration dates
    char date[32], edate[32];
    {
        struct tm tmbuf, *tm;

        tm = gmtime_r(&w->response.data->date, &tmbuf);
        strftime(date, sizeof(date), "%a, %d %b %Y %H:%M:%S %Z", tm);

            

Reported by FlawFinder.

              #endif  /* NETDATA_INTERNAL_CHECKS */
    }

    char filename[FILENAME_MAX+1];
    url = filename;
    strncpyz(filename, w->last_url, FILENAME_MAX);
    tok = mystrsep(&url, "?");
    buffer_flush(w->response.data);
    return mysendfile(w, (tok && *tok)?tok:"/");

            

Reported by FlawFinder.

              
        case HTTP_VALIDATION_INCOMPLETE:
            if(w->response.data->len > NETDATA_WEB_REQUEST_MAX_SIZE) {
                strcpy(w->last_url, "too big request");

                debug(D_WEB_CLIENT_ACCESS, "%llu: Received request is too big (%zu bytes).", w->id, w->response.data->len);

                buffer_flush(w->response.data);
                buffer_sprintf(w->response.data, "Received request is too big  (%zu bytes).\r\n", w->response.data->len);

            

Reported by FlawFinder.

              from collections import defaultdict
from json import loads

from bases.FrameworkServices.UrlService import UrlService

ORDER = [
    'response_statuses',
    'response_codes',
    'detailed_response_codes',

            

Reported by Pylint.

              # -*- coding: utf-8 -*-
# Description: traefik netdata python.d module
# Author: Alexandre Menezes (@ale_menezes)
# SPDX-License-Identifier: GPL-3.0-or-later

from collections import defaultdict
from json import loads

from bases.FrameworkServices.UrlService import UrlService

            

Reported by Pylint.

              
CHARTS = {
    'response_statuses': {
        'options': [None, 'Response statuses', 'requests/s', 'responses', 'traefik.response_statuses', 'stacked'],
        'lines': [
            ['successful_requests', 'success', 'incremental'],
            ['server_errors', 'error', 'incremental'],
            ['redirects', 'redirect', 'incremental'],
            ['bad_requests', 'bad', 'incremental'],

            

Reported by Pylint.

                      ]
    },
    'response_codes': {
        'options': [None, 'Responses by codes', 'requests/s', 'responses', 'traefik.response_codes', 'stacked'],
        'lines': [
            ['2xx', None, 'incremental'],
            ['5xx', None, 'incremental'],
            ['3xx', None, 'incremental'],
            ['4xx', None, 'incremental'],

            

Reported by Pylint.

                      ]
    },
    'detailed_response_codes': {
        'options': [None, 'Detailed response codes', 'requests/s', 'responses', 'traefik.detailed_response_codes',
                    'stacked'],
        'lines': []
    },
    'requests': {
        'options': [None, 'Requests', 'requests/s', 'requests', 'traefik.requests', 'line'],

            

Reported by Pylint.

                      ]
    },
    'total_response_time': {
        'options': [None, 'Total response time', 'seconds', 'timings', 'traefik.total_response_time', 'line'],
        'lines': [
            ['total_response_time_sec', 'response', 'absolute', 1, 10000]
        ]
    },
    'average_response_time': {

            

Reported by Pylint.

                      ]
    },
    'average_response_time': {
        'options': [None, 'Average response time', 'milliseconds', 'timings', 'traefik.average_response_time', 'line'],
        'lines': [
            ['average_response_time_sec', 'response', 'absolute', 1, 1000]
        ]
    },
    'average_response_time_per_iteration': {

            

Reported by Pylint.

              ]


class Service(UrlService):
    def __init__(self, configuration=None, name=None):
        UrlService.__init__(self, configuration=configuration, name=name)
        self.url = self.configuration.get('url', 'http://localhost:8080/health')
        self.order = ORDER
        self.definitions = CHARTS

            

Reported by Pylint.

              
        return self.data or None

    def get_data_per_code_status(self, raw_data):
        data = defaultdict(int)
        for code, value in raw_data['total_status_code_count'].items():
            code_prefix = code[0]
            if code_prefix == '1' or code_prefix == '2' or code == '304':
                data['successful_requests'] += value

            

Reported by Pylint.

                              data['other_requests'] += value
        self.data.update(data)

    def get_data_per_code_family(self, raw_data):
        data = defaultdict(int)
        for code, value in raw_data['total_status_code_count'].items():
            code_prefix = code[0]
            if code_prefix == '1':
                data['1xx'] += value

            

Reported by Pylint.

                      // we created it

        // chown it to match the required user
        if(chown(dir, uid, gid) == -1)
            error("Cannot chown directory '%s' to %u:%u", dir, (unsigned int)uid, (unsigned int)gid);
    }
    else if(errno != EEXIST)
        // log an error only if the directory does not exist
        error("Cannot create directory '%s'", dir);

            

Reported by FlawFinder.

                  clean_directory(netdata_configured_lock_dir);

    if(pidfile[0]) {
        if(chown(pidfile, uid, gid) == -1)
            error("Cannot chown '%s' to %u:%u", pidfile, (unsigned int)uid, (unsigned int)gid);
    }

    int ngroups = (int)sysconf(_SC_NGROUPS_MAX);
    gid_t *supplementary_groups = NULL;

            

Reported by FlawFinder.

                  }

    // check the environment
    char *s = getenv("OOMScoreAdjust");
    if(!s || !*s) {
        snprintfz(buf, 30, "%d", (int)wanted_score);
        s = buf;
    }


            

Reported by FlawFinder.

              #include "common.h"
#include <sched.h>

char pidfile[FILENAME_MAX + 1] = "";
char claimingdirectory[FILENAME_MAX + 1];
char exepath[FILENAME_MAX + 1];

void get_netdata_execution_path(void)
{

            

Reported by FlawFinder.

              #include <sched.h>

char pidfile[FILENAME_MAX + 1] = "";
char claimingdirectory[FILENAME_MAX + 1];
char exepath[FILENAME_MAX + 1];

void get_netdata_execution_path(void)
{
    int ret;

            

Reported by FlawFinder.

              
char pidfile[FILENAME_MAX + 1] = "";
char claimingdirectory[FILENAME_MAX + 1];
char exepath[FILENAME_MAX + 1];

void get_netdata_execution_path(void)
{
    int ret;
    size_t exepath_size = 0;

            

Reported by FlawFinder.

              #endif

static void oom_score_adj(void) {
    char buf[30 + 1];
    long long int old_score, wanted_score = OOM_SCORE_ADJ_MAX, final_score = 0;

    // read the existing score
    if(read_single_signed_number_file("/proc/self/oom_score_adj", &old_score)) {
        error("Out-Of-Memory (OOM) score setting is not supported on this system.");

            

Reported by FlawFinder.

                  }

    int written = 0;
    int fd = open("/proc/self/oom_score_adj", O_WRONLY);
    if(fd != -1) {
        snprintfz(buf, 30, "%d", (int)wanted_score);
        ssize_t len = strlen(buf);
        if(len > 0 && write(fd, buf, (size_t)len) == len) written = 1;
        close(fd);

            

Reported by FlawFinder.

                  // generate our pid file
    int pidfd = -1;
    if(pidfile[0]) {
        pidfd = open(pidfile, O_WRONLY | O_CREAT, 0644);
        if(pidfd >= 0) {
            if(ftruncate(pidfd, 0) != 0)
                error("Cannot truncate pidfile '%s'.", pidfile);

            char b[100];

            

Reported by FlawFinder.

                          if(ftruncate(pidfd, 0) != 0)
                error("Cannot truncate pidfile '%s'.", pidfile);

            char b[100];
            sprintf(b, "%d\n", getpid());
            ssize_t i = write(pidfd, b, strlen(b));
            if(i <= 0)
                error("Cannot write pidfile '%s'.", pidfile);
        }

            

Reported by FlawFinder.

              import json
import re

from bases.FrameworkServices.UrlService import UrlService

REGEX = re.compile(r'([a-z][a-z ]+): ([\d.]+)')

POOL_INFO = [
    ('active processes', 'active'),

            

Reported by Pylint.

              # -*- coding: utf-8 -*-
# Description: PHP-FPM netdata python.d module
# Author: Pawel Krupa (paulfantom)
# Author: Ilya Mashchenko (ilyam8)
# SPDX-License-Identifier: GPL-3.0-or-later

import json
import re


            

Reported by Pylint.

              ]


def average(collection):
    return sum(collection, 0.0) / max(len(collection), 1)


CALC = [
    ('min', min),

            

Reported by Pylint.

              
CHARTS = {
    'connections': {
        'options': [None, 'PHP-FPM Active Connections', 'connections', 'active connections', 'phpfpm.connections',
                    'line'],
        'lines': [
            ['active'],
            ['maxActive', 'max active'],
            ['idle']

            

Reported by Pylint.

                      ]
    },
    'performance': {
        'options': [None, 'PHP-FPM Performance', 'status', 'performance', 'phpfpm.performance', 'line'],
        'lines': [
            ['reached', 'max children reached'],
            ['slow', 'slow requests']
        ]
    },

            

Reported by Pylint.

                      ]
    },
    'request_duration': {
        'options': [None, 'PHP-FPM Requests Duration Among All Idle Processes', 'milliseconds', 'request duration',
                    'phpfpm.request_duration',
                    'line'],
        'lines': [
            ['minReqDur', 'min', 'absolute', 1, 1000],
            ['maxReqDur', 'max', 'absolute', 1, 1000],

            

Reported by Pylint.

                      ]
    },
    'request_cpu': {
        'options': [None, 'PHP-FPM Last Request CPU Usage Among All Idle Processes', 'percentage', 'request CPU',
                    'phpfpm.request_cpu', 'line'],
        'lines': [
            ['minReqCpu', 'min'],
            ['maxReqCpu', 'max'],
            ['avgReqCpu', 'avg']

            

Reported by Pylint.

                      ]
    },
    'request_mem': {
        'options': [None, 'PHP-FPM Last Request Memory Usage Among All Idle Processes', 'KB', 'request memory',
                    'phpfpm.request_mem', 'line'],
        'lines': [
            ['minReqMem', 'min', 'absolute', 1, 1024],
            ['maxReqMem', 'max', 'absolute', 1, 1024],
            ['avgReqMem', 'avg', 'absolute', 1, 1024]

            

Reported by Pylint.

              }


class Service(UrlService):
    def __init__(self, configuration=None, name=None):
        UrlService.__init__(self, configuration=configuration, name=name)
        self.order = ORDER
        self.definitions = CHARTS
        self.url = self.configuration.get('url', 'http://localhost/status?full&json')

            

Reported by Pylint.

              }


class Service(UrlService):
    def __init__(self, configuration=None, name=None):
        UrlService.__init__(self, configuration=configuration, name=name)
        self.order = ORDER
        self.definitions = CHARTS
        self.url = self.configuration.get('url', 'http://localhost/status?full&json')

            

Reported by Pylint.

              
    while (sqlite3_step(res_chart) == SQLITE_ROW) {
        char id[512];
        sprintf(id, "%s.%s", sqlite3_column_text(res_chart, 3), sqlite3_column_text(res_chart, 1));
        RRDSET *st = rrdset_find(host, id);
        if (st && !rrdset_flag_check(st, RRDSET_FLAG_ARCHIVED))
            continue;

        if (c)

            

Reported by FlawFinder.

              
    while (sqlite3_step(res) == SQLITE_ROW) {
        char id[512];
        sprintf(id, "%s.%s", sqlite3_column_text(res, 3), sqlite3_column_text(res, 1));

        if (!st || uuid_compare(*(uuid_t *)sqlite3_column_blob(res, 7), chart_id)) {
            if (unlikely(st && !st->counter)) {
                freez(st->context);
                freez((char *) st->name);

            

Reported by FlawFinder.

              int sql_init_database(void)
{
    char *err_msg = NULL;
    char sqlite_database[FILENAME_MAX + 1];
    int rc;

    fatal_assert(0 == uv_mutex_init(&sqlite_transaction_lock));

    snprintfz(sqlite_database, FILENAME_MAX, "%s/netdata-meta.db", netdata_configured_cache_dir);

            

Reported by FlawFinder.

                  int rc;

#ifdef NETDATA_INTERNAL_CHECKS
    char uuid_str[GUID_LEN + 1];
    uuid_unparse_lower(*dimension_uuid, uuid_str);
    debug(D_METADATALOG,"Deleting dimension uuid %s", uuid_str);
#endif

    if (unlikely(!res)) {

            

Reported by FlawFinder.

                      error_report("Failed to reset statement when searching for a chart UUID, rc = %d", rc);

#ifdef NETDATA_INTERNAL_CHECKS
    char  uuid_str[GUID_LEN + 1];
    if (likely(uuid)) {
        uuid_unparse_lower(*uuid, uuid_str);
        debug(D_METADATALOG, "Found UUID %s for chart %s.%s", uuid_str, type, name ? name : id);
    }
    else

            

Reported by FlawFinder.

                  uuid_generate(*uuid);

#ifdef NETDATA_INTERNAL_CHECKS
    char uuid_str[GUID_LEN + 1];
    uuid_unparse_lower(*uuid, uuid_str);
    debug(D_METADATALOG,"Generating uuid [%s] for chart %s under host %s", uuid_str, st->id, st->rrdhost->hostname);
#endif

    rc = update_chart_metadata(uuid, st, id, name);

            

Reported by FlawFinder.

                  size_t dimensions = 0;

    while (sqlite3_step(res_chart) == SQLITE_ROW) {
        char id[512];
        sprintf(id, "%s.%s", sqlite3_column_text(res_chart, 3), sqlite3_column_text(res_chart, 1));
        RRDSET *st = rrdset_find(host, id);
        if (st && !rrdset_flag_check(st, RRDSET_FLAG_ARCHIVED))
            continue;


            

Reported by FlawFinder.

                      goto failed;
    }

    char uuid_str[GUID_LEN + 1];
    uuid_unparse_lower(*((uuid_t *) sqlite3_column_blob(res, 0)), uuid_str);

    host = callocz(1, sizeof(RRDHOST));

    set_host_properties(host, sqlite3_column_int(res, 2), RRD_MEMORY_MODE_DBENGINE, hostname,

            

Reported by FlawFinder.

                  }

    RRDSET *st = NULL;
    char machine_guid[GUID_LEN + 1];
    uuid_unparse_lower(host->host_uuid, machine_guid);
    uuid_t rrdeng_uuid;
    uuid_t chart_id;

    while (sqlite3_step(res) == SQLITE_ROW) {

            

Reported by FlawFinder.

                  uuid_t chart_id;

    while (sqlite3_step(res) == SQLITE_ROW) {
        char id[512];
        sprintf(id, "%s.%s", sqlite3_column_text(res, 3), sqlite3_column_text(res, 1));

        if (!st || uuid_compare(*(uuid_t *)sqlite3_column_blob(res, 7), chart_id)) {
            if (unlikely(st && !st->counter)) {
                freez(st->context);

            

Reported by FlawFinder.