flowtask 5.8.4__cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

plugins/sources/newrelic.py

@@ -0,0 +1,262 @@
+from typing import Any
+from querysource.exceptions import (
+    DriverError,
+    QueryError,
+    DataNotFound,
+    ConfigError
+)
+from querysource.providers.sources import restSource
+
+gql = '''
+{{
+   actor {{
+      account(id: {account_id}) {{
+         nrql(timeout: 120 query: "{sql}") {{
+            results
+         }}
+      }}
+   }}
+}}
+'''
+
+
+class newrelic(restSource):
+    """
+      New Relic NQL
+        API for get events from NewRelic
+    """
+    url: str = 'https://api.newrelic.com/graphql'
+    nrql = "SELECT {fields} FROM {object} {options}"
+    auth_type: str = 'api_key'
+    method: str = 'post'  # All calls will be POST
+    data_format: str = 'json'
+    accept: str = "*/*"
+
+    def __post_init__(
+            self,
+            definition: dict = None,
+            conditions: dict = None,
+            request: Any = None,
+            **kwargs
+    ) -> None:
+
+        args = {}
+        print('NewRelic CONDITIONS> ', conditions)
+        self._query: dict = {}
+        self._range: str = '7 DAYS'
+        self._limit: str = 'MAX'
+        self.auth: dict = {
+            "API-Key": None
+        }
+        try:
+            self.type = definition.params['type']
+        except (ValueError, AttributeError):
+            self.type = None
+
+        if 'type' in self._conditions:
+            self.type = self._conditions['type']
+            del self._conditions['type']
+
+        if 'range' in self._conditions:
+            self._range = self._conditions['range']
+            del self._conditions['range']
+
+        if 'limit' in self._conditions:
+            self._limit = self._conditions['limit']
+            del self._conditions['limit']
+
+        if 'account_id' not in self._conditions:
+            self._conditions['account_id'] = self._env.get('NEW_RELIC_ACCOUNT')
+            if not self._conditions['account_id']:
+                try:
+                    self._conditions['account_id'] = definition.params['account_id']
+                except (ValueError, AttributeError) as ex:
+                    raise ConfigError(
+                        "NewRelic: Missing Account ID"
+                    ) from ex
+        if 'api_key' in self._conditions:
+            self.auth['API-Key'] = self._conditions['api_key']
+            del self._conditions['api_key']
+        else:
+            self.auth['API-Key'] = self._env.get('NEW_RELIC_API_KEY')
+            if not self.auth['API-Key']:
+                try:
+                    self.auth['API-Key'] = definition.params['api_key']
+                except (ValueError, AttributeError) as ex:
+                    raise ConfigError(
+                        "NewRelic: Missing API Key"
+                    ) from ex
+
+        # can build the Query
+        try:
+            self._fields = self._conditions['fields']
+            del self._conditions['fields']
+        except KeyError:
+            self._fields = '*'
+        # event name
+        try:
+            self._event = self._conditions['event']
+            del self._conditions['event']
+        except KeyError:
+            self._event = 'Agents'
+
+        ## URL parameters
+        self._args = args
+
+        if self.type == 'eventlist':
+            self._query = gql.format(
+                account_id=self._conditions['account_id'],
+                sql="SHOW EVENT TYPES SINCE 30 days AGO"
+            )
+        elif self.type == 'events':
+            try:
+                sql = self.nrql.format(
+                    fields=self._fields,
+                    object=self._event,
+                    options=f'SINCE {self._range} AGO LIMIT {self._limit}'
+                )
+            except Exception as err:
+                print(err)
+                raise
+            self._query = gql.format(
+                account_id=self._conditions['account_id'],
+                sql=sql
+            )
+        elif self.type == 'agents':
+            sql = self.nrql.format(
+                fields=self._fields,
+                object='Agents',
+                options=f'SINCE {self._range} AGO LIMIT {self._limit}'
+            )
+            self._query = gql.format(
+                account_id=self._conditions['account_id'],
+                sql=sql
+            )
+        elif self.type == 'sip':
+            sql = self.nrql.format(
+                fields=self._fields,
+                object='Sip',
+                options=f'SINCE {self._range} AGO TIMESERIES'
+            )
+            self._query = gql.format(
+                account_id=self._conditions['account_id'],
+                sql=sql
+            )
+
+    async def eventlist(self):
+        try:
+            query = gql.format(
+                account_id=self._conditions['account_id'],
+                sql="SHOW EVENT TYPES SINCE 30 days AGO"
+            )
+        except KeyError as err:
+            self.logger.error(f'NewRelic: Missing key: {err}')
+        try:
+            self._result = await self.query(query)
+            return self._result
+        except Exception as ex:
+            self.logger.exception(ex)
+            raise QueryError(
+                f"NewRelic: {ex}"
+            ) from ex
+
+    async def events(self):
+        try:
+            sql = self.nrql.format(
+                fields=self._fields,
+                object=self._event,
+                options=f'SINCE {self._range} AGO LIMIT {self._limit}'
+            )
+        except Exception as err:
+            print(err)
+            raise
+        query = gql.format(
+            account_id=self._conditions['account_id'],
+            sql=sql
+        )
+        try:
+            self._result = await self.query(query)
+            return self._result
+        except Exception as ex:
+            self.logger.exception(ex)
+            raise QueryError(
+                f"NewRelic: {ex}"
+            ) from ex
+
+    async def sip(self):
+        sql = self.nrql.format(
+            fields=self._fields,
+            object='Sip',
+            options=f'SINCE {self._range} AGO TIMESERIES'
+        )
+        query = gql.format(
+            account_id=self._conditions['account_id'],
+            sql=sql
+        )
+        try:
+            self._result = await self.query(query)
+            return self._result
+        except Exception as ex:
+            self.logger.exception(ex)
+            raise QueryError(
+                f"NewRelic: {ex}"
+            ) from ex
+
+    async def agents(self):
+        sql = self.nrql.format(
+            fields=self._fields,
+            object='Agents',
+            options=f'SINCE {self._range} AGO LIMIT {self._limit}'
+        )
+        query = gql.format(
+            account_id=self._conditions['account_id'],
+            sql=sql
+        )
+        try:
+            self._result = await self.query(query)
+            return self._result
+        except Exception as ex:
+            self.logger.exception(ex)
+            raise QueryError(
+                f"NewRelic: {ex}"
+            ) from ex
+
+    async def query(self, data: str = None):
+        result = None
+        if not data:
+            data = self._query
+        if not data:
+            raise DriverError(
+                "New Relic: GraphQL query is missing"
+            )
+        try:
+            result, error = await self.request(
+                self.url,
+                self.method,
+                data=data
+            )
+            if not result:
+                raise DataNotFound(
+                    f"NewRelic: No Data was found: {error}".format(error)
+                )
+            elif error:
+                raise DriverError(str(error))
+            elif 'errors' in result:
+                raise DriverError(result['errors'][0]['message'])
+        except DataNotFound:
+            raise
+        except Exception as ex:
+            self.logger.exception(ex)
+            raise QueryError(
+                f"NewRelic: {ex}"
+            ) from ex
+        # if result then
+        try:
+            # {'data': {'actor': {'account': {'nrql': {'results'
+            result = result['data']['actor']['account']['nrql']['results']
+        except (ValueError, KeyError) as ex:
+            raise QueryError(
+                f'NewRelic: Incorrect Data result format: {ex}'
+            ) from ex
+        self._result = result
+        return result

plugins/sources/uap.py

@@ -0,0 +1,268 @@
+from typing import Any
+from urllib.parse import urlencode
+from asyncdb.exceptions import NoDataFound, ProviderError
+from navconfig.logging import logging
+from querysource.exceptions import DataNotFound, DriverError, QueryException
+from querysource.providers.sources import restSource
+
+
+class uap(restSource):
+    """UAP.
+
+        Get all information from UAP API
+    """
+    base_url: str = 'https://{uap_url}/api/v1/{type}'
+    type = 'adp_workers'
+    _token = ''
+    _page = 1
+    _more_results: bool = True
+    _page_size: int = 1000
+
+    def __post_init__(
+            self,
+            definition: dict = None,
+            conditions: dict = None,
+            request: Any = None,
+            **kwargs
+    ) -> None:
+
+        args = {}
+
+        print('UAP CONDITIONS> ', conditions)
+        try:
+            self._program = self._conditions['var']
+            del self._conditions['var']
+        except KeyError:
+            self._program = None
+
+        if 'program' in self._conditions:
+            self._program = self._conditions['program']
+            del self._conditions['program']
+
+        try:
+            self.type = definition.params['type']
+        except (ValueError, AttributeError):
+            try:
+                self.type = self.kwargs['method']
+            except KeyError:
+                pass
+
+        if 'type' in self._conditions:
+            self.type = self._conditions['type']
+            del self._conditions['type']
+
+        if 'method' in self._conditions:
+            self.type = self._conditions['method']
+            del self._conditions['method']
+
+        # define type of function:
+        args['type'] = self.type
+
+        # authentication
+        if 'token' not in conditions:
+            self._token = self._env.get('UAP_TOKEN')
+            if not self._token:
+                try:
+                    self._token = definition.params['token']
+                except (ValueError, AttributeError) as ex:
+                    raise ValueError(
+                        "UAP: Token missing"
+                    ) from ex
+        else:
+            self._token = self._conditions['token']
+            del self._conditions['token']
+
+        try:
+            host = definition.params['host']
+        except (KeyError, ValueError, AttributeError):
+            host = 'uap.trocglobal.com'
+
+        args['uap_url'] = self._env.get(
+            'UAP_API',
+            fallback=host
+        )
+
+        try:
+            self._page_size = self._conditions['pagesize']
+            del self._conditions['pagesize']
+        except (ValueError, KeyError):
+            try:
+                self._page_size = definition.params['pagesize']
+            except (AttributeError, KeyError):
+                pass
+
+        self._conditions['page_size'] = self._page_size
+
+        try:
+            self._more_results = self._conditions['more_results']
+            del self._conditions['more_results']
+        except (ValueError, KeyError):
+            self._more_results = True
+
+        try:
+            self._pages = self._conditions['pages']
+            del self._conditions['pages']
+        except (ValueError, KeyError):
+            self._pages = None
+
+        self._headers = {
+              "Authorization": f"Token {self._token}",
+              "Accept-Encoding": "gzip, deflate, br",
+              "Content-Type": "application/json",
+              "Host": host,
+              **self._headers
+        }
+
+        try:
+            del self._conditions['refresh']
+            del self._conditions['ENV']
+        except (KeyError, ValueError, TypeError):
+            pass
+
+        if self.type in ('adp-workers', 'adp_workers'):
+             self.url = 'https://{uap_url}/api/v1/adp-workers'
+        else:
+            if not self._program:
+                self.url = 'https://{uap_url}/api/v1/volt/{type}'
+            else:
+                self.url = 'https://{uap_url}/api/v1/volt/{type}/{program}'
+
+        ## URL parameters
+        self._args = args
+
+    async def get_next_result(self, result):
+        r = result['results']
+        _next = True
+        while _next is True:
+            if self._pages:
+                if self._page > self._pages:
+                    # no more pages
+                    break
+            self._page = self._page + 1
+            url = self.build_url(self.url, queryparams=urlencode(
+                {"page": self._page}
+             )
+            )
+            print(f'Fetching page {self._page}')
+            try:
+                res, error = await self.request(url)
+                if res:
+                    pg = res['pagination']
+                    r = r + res['results']
+                    _next = bool(pg['next'])
+                else:
+                    print('Error Continue')
+                    print(error)
+                    continue
+            except Exception as err: # pylint: disable=W0703
+                print('Error HERE')
+                print(err)
+                _next = False
+        print('::  Returning Results')
+        return r
+
+    async def adp_workers(self):
+        self.type = 'adp-workers'
+        self._args['type'] = self.type
+        try:
+            self._result = await self.query()
+            return self._result
+        except Exception as err:
+            logging.exception(str(err))
+            raise
+
+
+    async def events(self):
+        self.type = 'events'
+        self._args['type'] = self.type
+        self._args['program'] = self._program
+        try:
+            self._result = await self.query()
+            return self._result
+        except Exception as e: # pylint: disable=W0703
+            logging.exception(e)
+        return False
+
+    async def users(self):
+        self.type = 'users'
+        self._args['type'] = self.type
+        self._args['program'] = self._program
+        try:
+            self._result = await self.query()
+            return self._result
+        except Exception as e: # pylint: disable=W0703
+            logging.exception(e)
+        return False
+
+
+    async def query(self, url:str = None, params: dict = None, data: dict = None): # pylint: disable=W0237
+        self._result = None
+        if url:
+            self._args['program'] = self._program
+            self.url = self.build_url(
+                url,
+                queryparams=urlencode(params)
+            )
+        else:
+            self._args['program'] = self._program
+            # create URL
+            self.url = self.build_url(
+                self.url,
+                args=self._args,
+                queryparams=urlencode(self._conditions)
+            )
+        try:
+            result, error = await self.request(
+                self.url, self.method, data=data
+            )
+            if not result:
+                raise DataNotFound(
+                    f"UAP: No Data was found: {error}"
+                )
+            elif error:
+                raise DriverError(str(error))
+            else:
+                try:
+                    if result['errorCode']:
+                        raise NoDataFound(
+                            message=result['errorMessage'],
+                            code=result['errorCode']
+                        )
+                except (TypeError, KeyError):
+                    pass
+            # processing data:
+            pagination = {}
+            try:
+                pagination = result['pagination']
+            except KeyError:
+                pagination['next'] = False
+            if self._more_results is True and bool(pagination['next']) is True:
+                self._result = await self.get_next_result(result)
+            else:
+                try:
+                    self._result = result['results']
+                except (TypeError, KeyError) as ex:
+                    raise DataNotFound(
+                        "Data not found: {ex}"
+                    ) from ex
+            return self._result
+        except (DataNotFound, NoDataFound) as err:
+            raise DataNotFound(
+                str(err)
+            ) from err
+        except NoDataFound as err:
+            print("UAP NO DATA FOUND: === ", err)
+            raise DataNotFound(
+                message=str(err)
+            ) from err
+        except (ProviderError, DriverError) as err:
+            print("UAP PROVIDER ERROR: === ", err)
+            raise DriverError(
+                message=err.message, code=err.status_code
+            ) from err
+        except Exception as err:
+            print("UAP ERROR: === ", err)
+            self._result = None
+            raise QueryException(
+                message=str(err)
+            ) from err