How to use the ceilometer.openstack.common.log.getLogger function in ceilometer

"""
A remote procedure call (rpc) abstraction.

For some wrappers that add message versioning to rpc, see:
    rpc.dispatcher
    rpc.proxy
"""

from oslo.config import cfg

from ceilometer.openstack.common import importutils
from ceilometer.openstack.common import log as logging


LOG = logging.getLogger(__name__)


rpc_opts = [
    cfg.StrOpt('rpc_backend',
               default='%s.impl_kombu' % __package__,
               help="The messaging module to use, defaults to kombu."),
    cfg.IntOpt('rpc_thread_pool_size',
               default=64,
               help='Size of RPC thread pool'),
    cfg.IntOpt('rpc_conn_pool_size',
               default=30,
               help='Size of RPC connection pool'),
    cfg.IntOpt('rpc_response_timeout',
               default=60,
               help='Seconds to wait for a response from call or multicall'),
    cfg.IntOpt('rpc_cast_timeout',

# under the License.
"""MongoDB storage backend"""

from oslo_config import cfg
import pymongo

from ceilometer.alarm.storage import pymongo_base
from ceilometer.openstack.common import log
from ceilometer import storage
from ceilometer.storage import impl_mongodb
from ceilometer.storage.mongo import utils as pymongo_utils

cfg.CONF.import_opt('alarm_history_time_to_live', 'ceilometer.alarm.storage',
                    group="database")

LOG = log.getLogger(__name__)


class Connection(pymongo_base.Connection):
    """Put the alarm data into a MongoDB database."""

    CONNECTION_POOL = pymongo_utils.ConnectionPool()

    def __init__(self, url):

        # NOTE(jd) Use our own connection pooling on top of the Pymongo one.
        # We need that otherwise we overflow the MongoDB instance with new
        # connection since we instantiate a Pymongo client each time someone
        # requires a new storage connection.
        self.conn = self.CONNECTION_POOL.connect(url)

        # Require MongoDB 2.4 to use $setOnInsert

#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""Base class for plugin loader.
"""

from stevedore import enabled

from ceilometer.openstack.common import log


LOG = log.getLogger(__name__)


def should_use_extension(namespace, ext, disabled_names):
    """Return boolean indicating whether the extension
    should be used.

    Tests the extension against a couple of criteria to see whether it
    should be used, logs the reason it is not used if not, and then
    returns the result.
    """
    if ext.name in disabled_names:
        LOG.debug(
            '%s extension %r disabled through configuration setting',
            namespace, ext.name,
        )
        return False

#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""Given an incoming message, process it through the registered converters
and publish the results.
"""

import pkg_resources

from ceilometer.openstack.common import log

LOG = log.getLogger(__name__)


class NotificationDispatcher(object):
    """Manages invoking plugins to convert notification messages to counters.
    """

    def __init__(self, plugin_namespace, publish_func):
        self.plugin_namespace = plugin_namespace
        self.publish_func = publish_func
        self.handlers = {}
        self.topics = set()
        self._load_plugins()

    def _load_plugins(self):
        # Listen for notifications from nova
        for ep in pkg_resources.iter_entry_points(self.plugin_namespace):

default='127.0.0.1',
               help='Host to locate redis'),
    cfg.IntOpt('port',
               default=6379,
               help='Use this port to connect to redis host.'),
    cfg.StrOpt('password',
               default=None,
               help='Password for Redis server. (optional)'),
]

CONF = cfg.CONF
opt_group = cfg.OptGroup(name='matchmaker_redis',
                         title='Options for Redis-based MatchMaker')
CONF.register_group(opt_group)
CONF.register_opts(matchmaker_redis_opts, opt_group)
LOG = logging.getLogger(__name__)


class RedisExchange(mm_common.Exchange):
    def __init__(self, matchmaker):
        self.matchmaker = matchmaker
        self.redis = matchmaker.redis
        super(RedisExchange, self).__init__()


class RedisTopicExchange(RedisExchange):
    """Exchange where all topic keys are split, sending to second half.

    i.e. "compute.host" sends a message to "compute" running on "host"
    """
    def run(self, topic):
        while True:

import wsmeext.pecan as wsme_pecan

import ceilometer
from ceilometer.alarm import service as alarm_service
from ceilometer.alarm.storage import models as alarm_models
from ceilometer.api import rbac
from ceilometer.event.storage import models as event_models
from ceilometer.i18n import _
from ceilometer import messaging
from ceilometer.openstack.common import context
from ceilometer.openstack.common import log
from ceilometer import sample
from ceilometer import storage
from ceilometer import utils

LOG = log.getLogger(__name__)


ALARM_API_OPTS = [
    cfg.BoolOpt('record_history',
                default=True,
                help='Record alarm change events.'
                ),
    cfg.IntOpt('user_alarm_quota',
               default=None,
               help='Maximum number of alarms defined for a user.'
               ),
    cfg.IntOpt('project_alarm_quota',
               default=None,
               help='Maximum number of alarms defined for a project.'
               ),
]

# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""Converters for producing compute CPU sample messages from notification
events.
"""
from oslo.utils import timeutils

from ceilometer.compute import notifications
from ceilometer.openstack.common.gettextutils import _
from ceilometer.openstack.common import log
from ceilometer import sample

LOG = log.getLogger(__name__)


class ComputeMetricsNotificationBase(notifications.ComputeNotificationBase):
    """Convert compute.metrics.update notifications into Samples."""
    event_types = ['compute.metrics.update']
    metric = None
    sample_type = None
    unit = None

    @staticmethod
    def _get_sample(message, name):
        try:
            for metric in message['payload']['metrics']:
                if name == metric['name']:
                    info = {'payload': metric,
                            'event_type': message['event_type'],

# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.

from ceilometer.event.storage import base
from ceilometer.i18n import _LI
from ceilometer.openstack.common import log

LOG = log.getLogger(__name__)


class Connection(base.Connection):
    """Log event data."""

    @staticmethod
    def clear_expired_event_data(ttl):
        """Clear expired data from the backend storage system.

        Clearing occurs according to the time-to-live.

        :param ttl: Number of seconds to keep records for.
        """
        LOG.info(_LI("Dropping event data with TTL %d"), ttl)

# License for the specific language governing permissions and limitations
# under the License.
"""Publish a counter using the preferred RPC mechanism.
"""

import itertools

from oslo.config import cfg

from ceilometer.collector import meter as meter_api
from ceilometer.openstack.common import log
from ceilometer.openstack.common import rpc
from ceilometer import publisher


LOG = log.getLogger(__name__)

PUBLISH_OPTS = [
    cfg.StrOpt('metering_topic',
               default='metering',
               help='the topic ceilometer uses for metering messages',
               ),
]


def register_opts(config):
    """Register the options for publishing metering messages.
    """
    config.register_opts(PUBLISH_OPTS)


register_opts(cfg.CONF)

from oslo.config import cfg

from ceilometer.openstack.common.gettextutils import _
from ceilometer.openstack.common import importutils
from ceilometer.openstack.common import log as logging


list_notifier_drivers_opt = cfg.MultiStrOpt(
    'list_notifier_drivers',
    default=['ceilometer.openstack.common.notifier.no_op_notifier'],
    help='List of drivers to send notifications')

CONF = cfg.CONF
CONF.register_opt(list_notifier_drivers_opt)

LOG = logging.getLogger(__name__)

drivers = None


class ImportFailureNotifier(object):
    """Noisily re-raises some exception over-and-over when notify is called."""

    def __init__(self, exception):
        self.exception = exception

    def notify(self, context, message):
        raise self.exception


def _get_drivers():
    """Instantiates and returns drivers based on the flag values."""