init_auth(login_manager, conf.auth_backend)

  from freshmaker import views  # noqa

  from freshmaker import log, conf, messaging, events, app

  from freshmaker.monitor import (

  from freshmaker.utils import load_classes

              super(FreshmakerConsumer, self).validate(message)

      def consume(self, message):

          # Sometimes, the messages put into our queue are artificially put there

          # by other parts of our own codebase.  If they are already abstracted

          if not msg:

              # We do not log here anything, because it would create lot of

              # useless messages in the logs.

              return

          # Primary work is done here.

              # to have global app_context.

              with app.app_context():

                  self.process_event(msg)

          except Exception:

              log.exception('Failed while handling {0!r}'.format(msg))

          if self.stop_condition and self.stop_condition(message):

      :param dict msg: the message contents of the message (typically JSON)

      :return: the value returned from underlying backend "send" method.

      """

      try:

          handler = _messaging_backends[conf.messaging_sender]['publish']

      except KeyError:

          raise KeyError("No messaging backend found for %r" % conf.messaging)

  def _fedmsg_publish(topic, msg):

  # -*- coding: utf-8 -*-

  #

  # Permission is hereby granted, free of charge, to any person obtaining a copy

  # of this software and associated documentation files (the "Software"), to deal

  # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  # SOFTWARE.

  import os

  import tempfile

      ProcessCollector, CollectorRegistry, Counter, multiprocess,

  from sqlalchemy import event

  if not os.environ.get('prometheus_multiproc_dir'):

      os.environ.setdefault('prometheus_multiproc_dir', tempfile.mkdtemp())

  registry = CollectorRegistry()

  ProcessCollector(registry=registry)

  multiprocess.MultiProcessCollector(registry)

  # Generic metrics

      'Total number of messages received',

      registry=registry)

      'Number of received messages, which were ignored',

      registry=registry)

      'Number of received messages, which were processed successfully',

      registry=registry)

      'Number of received messages, which failed during processing',

      registry=registry)

  db_dbapi_error_counter = Counter(

      'db_dbapi_error',

      'Number of DBAPI errors',

      'db_handle_error',

      'Number of exceptions during connection',

      registry=registry)

  db_transaction_rollback_counter = Counter(

      'db_transaction_rollback',

      'Number of transactions, which were rolled back',

      registry=registry)

  freshmaker_artifact_build_done_counter = Counter(

      'freshmaker_artifact_build_done',

      'Number of successful artifact builds',

      'EventAPI latency', registry=registry)

  from freshmaker.auth import login_required, requires_role, require_scopes

  from freshmaker.parsers.internal.manual_rebuild import FreshmakerManualRebuildParser

  from freshmaker.monitor import (

  api_v1 = {

      'event_types': {

              }

          },

      },

      'about': {

          'about': {

              'url': '/api/1/about/',

      'event_types': EventTypeAPI,

      'build_types': BuildTypeAPI,

      'build_states': BuildStateAPI,

      'about': AboutAPI,

  }

                               view_func=view,

                               **val['options'])

  register_api_v1()

  # -*- coding: utf-8 -*-

  #

  # Permission is hereby granted, free of charge, to any person obtaining a copy

  # of this software and associated documentation files (the "Software"), to deal

  # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  # SOFTWARE.

  import mock

  import freshmaker

  from freshmaker import app, db, events, models, login_manager

  from tests import helpers

  @login_manager.user_loader

  def user_loader(username):

          db.session.expire_all()

      def test_monitor_api_structure(self):

          self.assertEqual(

  class ConsumerTest(helpers.ModelsTestCase):

          return msg

      def _get_monitor_value(self, key):

          for line in resp.get_data(as_text=True).splitlines():

              k, v = line.split(" ")[:2]

              if k == key:

          global_consumer.return_value = consumer

          handle.return_value = [freshmaker.events.TestingEvent("ModuleBuilt handled")]

          msg = self._module_state_change_msg()

          consumer.consume(msg)

          event = consumer.incoming.get()

          self.assertEqual(event.msg_id, "ModuleBuilt handled")

          self.assertEqual(prev_counter_value + 1, counter_value)