py2docfx 0.1.16rc2051518__py3-none-any.whl → 0.1.17__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/opencensus/ext/azure/common/__init__.py

@@ -1,138 +1,138 @@
-# Copyright 2019, OpenCensus Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may 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.
-
-import logging
-import os
-import tempfile
-
-from opencensus.ext.azure.common.protocol import BaseObject
-
-INGESTION_ENDPOINT = 'ingestionendpoint'
-INSTRUMENTATION_KEY = 'instrumentationkey'
-TEMPDIR_PREFIX = "opencensus-python-"
-
-_logger = logging.getLogger(__name__)
-
-
-def process_options(options):
-    # Connection string/ikey
-    code_cs = parse_connection_string(options.connection_string)
-    code_ikey = options.instrumentation_key
-    env_cs = parse_connection_string(
-        os.getenv('APPLICATIONINSIGHTS_CONNECTION_STRING'))
-    env_ikey = os.getenv('APPINSIGHTS_INSTRUMENTATIONKEY')
-
-    # Deprecation note about explicit instrumentation key usage
-    if (not code_cs and code_ikey) or (not env_cs and env_ikey):
-        _logger.warning(
-            "DeprecationWarning: Explicitly using instrumentation key is"
-            "deprecated. Please use a connection string instead."
-        )
-
-    # The priority of which value takes on the instrumentation key is:
-    # 1. Key from explicitly passed in connection string
-    # 2. Key from explicitly passed in instrumentation key
-    # 3. Key from connection string in environment variable
-    # 4. Key from instrumentation key in environment variable
-    options.instrumentation_key = code_cs.get(INSTRUMENTATION_KEY) \
-        or code_ikey \
-        or env_cs.get(INSTRUMENTATION_KEY) \
-        or env_ikey
-    # The priority of the ingestion endpoint is as follows:
-    # 1. The endpoint explicitly passed in connection string
-    # 2. The endpoint from the connection string in environment variable
-    # 3. The default breeze endpoint
-    endpoint = code_cs.get(INGESTION_ENDPOINT) \
-        or env_cs.get(INGESTION_ENDPOINT) \
-        or 'https://dc.services.visualstudio.com'
-    options.endpoint = endpoint
-
-    # Authorization
-    # `azure.core.credentials.TokenCredential` class must be valid
-    if options.credential and not hasattr(options.credential, 'get_token'):
-        raise ValueError(
-            'Must pass in valid TokenCredential.'
-        )
-
-    # storage path
-    if options.storage_path is None:
-        TEMPDIR_SUFFIX = options.instrumentation_key or ""
-        options.storage_path = os.path.join(
-                tempfile.gettempdir(),
-                TEMPDIR_PREFIX + TEMPDIR_SUFFIX
-            )
-
-    # proxies
-    if options.proxies is None:
-        options.proxies = '{}'
-
-
-def parse_connection_string(connection_string):
-    if connection_string is None:
-        return {}
-    try:
-        pairs = connection_string.split(';')
-        result = dict(s.split('=') for s in pairs)
-        # Convert keys to lower-case due to case type-insensitive checking
-        result = {key.lower(): value for key, value in result.items()}
-    except Exception:
-        raise ValueError('Invalid connection string')
-    # Validate authorization
-    auth = result.get('authorization')
-    if auth is not None and auth.lower() != 'ikey':
-        raise ValueError('Invalid authorization mechanism')
-    # Construct the ingestion endpoint if not passed in explicitly
-    if result.get(INGESTION_ENDPOINT) is None:
-        endpoint_suffix = ''
-        location_prefix = ''
-        suffix = result.get('endpointsuffix')
-        if suffix is not None:
-            endpoint_suffix = suffix
-            # Get regional information if provided
-            prefix = result.get('location')
-            if prefix is not None:
-                location_prefix = prefix + '.'
-            endpoint = 'https://' + location_prefix + 'dc.' + endpoint_suffix
-            result[INGESTION_ENDPOINT] = endpoint
-        else:
-            # Default to None if cannot construct
-            result[INGESTION_ENDPOINT] = None
-    return result
-
-
-class Options(BaseObject):
-    def __init__(self, *args, **kwargs):
-        super(Options, self).__init__(*args, **kwargs)
-        process_options(self)
-
-    _default = BaseObject(
-        connection_string=None,
-        credential=None,  # Credential class used by AAD auth
-        enable_local_storage=True,
-        enable_standard_metrics=True,  # Used by metrics exporter, True to send standard metrics  # noqa: E501
-        endpoint='https://dc.services.visualstudio.com/v2/track',
-        export_interval=15.0,
-        grace_period=5.0,
-        instrumentation_key=None,
-        logging_sampling_rate=1.0,  # Used by log exporter, controls sampling
-        max_batch_size=100,
-        minimum_retry_interval=60,  # minimum retry interval in seconds
-        proxies=None,  # string maps url schemes to the url of the proxies
-        queue_capacity=8192,
-        storage_maintenance_period=60,
-        storage_max_size=50*1024*1024,  # 50MiB
-        storage_path=None,
-        storage_retention_period=7*24*60*60,
-        timeout=10.0,  # networking timeout in seconds
-    )
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may 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.
+
+import logging
+import os
+import tempfile
+
+from opencensus.ext.azure.common.protocol import BaseObject
+
+INGESTION_ENDPOINT = 'ingestionendpoint'
+INSTRUMENTATION_KEY = 'instrumentationkey'
+TEMPDIR_PREFIX = "opencensus-python-"
+
+_logger = logging.getLogger(__name__)
+
+
+def process_options(options):
+    # Connection string/ikey
+    code_cs = parse_connection_string(options.connection_string)
+    code_ikey = options.instrumentation_key
+    env_cs = parse_connection_string(
+        os.getenv('APPLICATIONINSIGHTS_CONNECTION_STRING'))
+    env_ikey = os.getenv('APPINSIGHTS_INSTRUMENTATIONKEY')
+
+    # Deprecation note about explicit instrumentation key usage
+    if (not code_cs and code_ikey) or (not env_cs and env_ikey):
+        _logger.warning(
+            "DeprecationWarning: Explicitly using instrumentation key is"
+            "deprecated. Please use a connection string instead."
+        )
+
+    # The priority of which value takes on the instrumentation key is:
+    # 1. Key from explicitly passed in connection string
+    # 2. Key from explicitly passed in instrumentation key
+    # 3. Key from connection string in environment variable
+    # 4. Key from instrumentation key in environment variable
+    options.instrumentation_key = code_cs.get(INSTRUMENTATION_KEY) \
+        or code_ikey \
+        or env_cs.get(INSTRUMENTATION_KEY) \
+        or env_ikey
+    # The priority of the ingestion endpoint is as follows:
+    # 1. The endpoint explicitly passed in connection string
+    # 2. The endpoint from the connection string in environment variable
+    # 3. The default breeze endpoint
+    endpoint = code_cs.get(INGESTION_ENDPOINT) \
+        or env_cs.get(INGESTION_ENDPOINT) \
+        or 'https://dc.services.visualstudio.com'
+    options.endpoint = endpoint
+
+    # Authorization
+    # `azure.core.credentials.TokenCredential` class must be valid
+    if options.credential and not hasattr(options.credential, 'get_token'):
+        raise ValueError(
+            'Must pass in valid TokenCredential.'
+        )
+
+    # storage path
+    if options.storage_path is None:
+        TEMPDIR_SUFFIX = options.instrumentation_key or ""
+        options.storage_path = os.path.join(
+                tempfile.gettempdir(),
+                TEMPDIR_PREFIX + TEMPDIR_SUFFIX
+            )
+
+    # proxies
+    if options.proxies is None:
+        options.proxies = '{}'
+
+
+def parse_connection_string(connection_string):
+    if connection_string is None:
+        return {}
+    try:
+        pairs = connection_string.split(';')
+        result = dict(s.split('=') for s in pairs)
+        # Convert keys to lower-case due to case type-insensitive checking
+        result = {key.lower(): value for key, value in result.items()}
+    except Exception:
+        raise ValueError('Invalid connection string')
+    # Validate authorization
+    auth = result.get('authorization')
+    if auth is not None and auth.lower() != 'ikey':
+        raise ValueError('Invalid authorization mechanism')
+    # Construct the ingestion endpoint if not passed in explicitly
+    if result.get(INGESTION_ENDPOINT) is None:
+        endpoint_suffix = ''
+        location_prefix = ''
+        suffix = result.get('endpointsuffix')
+        if suffix is not None:
+            endpoint_suffix = suffix
+            # Get regional information if provided
+            prefix = result.get('location')
+            if prefix is not None:
+                location_prefix = prefix + '.'
+            endpoint = 'https://' + location_prefix + 'dc.' + endpoint_suffix
+            result[INGESTION_ENDPOINT] = endpoint
+        else:
+            # Default to None if cannot construct
+            result[INGESTION_ENDPOINT] = None
+    return result
+
+
+class Options(BaseObject):
+    def __init__(self, *args, **kwargs):
+        super(Options, self).__init__(*args, **kwargs)
+        process_options(self)
+
+    _default = BaseObject(
+        connection_string=None,
+        credential=None,  # Credential class used by AAD auth
+        enable_local_storage=True,
+        enable_standard_metrics=True,  # Used by metrics exporter, True to send standard metrics  # noqa: E501
+        endpoint='https://dc.services.visualstudio.com/v2/track',
+        export_interval=15.0,
+        grace_period=5.0,
+        instrumentation_key=None,
+        logging_sampling_rate=1.0,  # Used by log exporter, controls sampling
+        max_batch_size=100,
+        minimum_retry_interval=60,  # minimum retry interval in seconds
+        proxies=None,  # string maps url schemes to the url of the proxies
+        queue_capacity=8192,
+        storage_maintenance_period=60,
+        storage_max_size=50*1024*1024,  # 50MiB
+        storage_path=None,
+        storage_retention_period=7*24*60*60,
+        timeout=10.0,  # networking timeout in seconds
+    )

py2docfx/venv/venv1/Lib/site-packages/opencensus/ext/azure/common/exporter.py

@@ -1,93 +1,93 @@
-# Copyright 2019, OpenCensus Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may 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.
-
-import atexit
-import threading
-import time
-
-from opencensus.common.schedule import Queue, QueueEvent
-from opencensus.ext.azure.common import Options
-from opencensus.trace import execution_context
-
-
-class BaseExporter(object):
-    def __init__(self, **options):
-        options = Options(**options)
-        self.export_interval = options.export_interval
-        self.max_batch_size = options.max_batch_size
-        # TODO: queue should be moved to tracer
-        # too much refactor work, leave to the next PR
-        self._queue = Queue(capacity=options.queue_capacity)
-        # TODO: worker should not be created in the base exporter
-        self._worker = Worker(self._queue, self)
-        self._worker.start()
-        atexit.register(self._worker.stop, options.grace_period)
-
-    # Ideally we don't want to have `emit`
-    # Exporter will have one public method - `export`, which is a blocking
-    # method, running inside worker threads.
-    def emit(self, batch, event=None):
-        raise NotImplementedError  # pragma: NO COVER
-
-    # TODO: we shouldn't have this at the beginning
-    # Tracer should own the queue, exporter shouldn't even know if the
-    # source is a queue or not.
-    # Tracer puts span_data into the queue.
-    # Worker gets span_data from the src (here is the queue) and feed into
-    # the dst (exporter).
-    # Exporter defines the MTU (max_batch_size) and export_interval.
-    # There can be one worker for each queue, or multiple workers for each
-    # queue, or shared workers among queues (e.g. queue for traces, queue
-    # for logs).
-    def export(self, items):
-        self._queue.puts(items, block=False)  # pragma: NO COVER
-
-
-class Worker(threading.Thread):
-    daemon = True
-
-    def __init__(self, src, dst):
-        self.src = src
-        self.dst = dst
-        self._stopping = False
-        super(Worker, self).__init__(
-            name="AzureExporter Worker"
-        )
-
-    def run(self):  # pragma: NO COVER
-        # Indicate that this thread is an exporter thread.
-        # Used to suppress tracking of requests in this thread
-        execution_context.set_is_exporter(True)
-        src = self.src
-        dst = self.dst
-        while True:
-            batch = src.gets(dst.max_batch_size, dst.export_interval)
-            if batch and isinstance(batch[-1], QueueEvent):
-                dst.emit(batch[:-1], event=batch[-1])
-                if batch[-1] is src.EXIT_EVENT:
-                    break
-                else:
-                    continue
-            dst.emit(batch)
-
-    def stop(self, timeout=None):  # pragma: NO COVER
-        start_time = time.time()
-        wait_time = timeout
-        if self.is_alive() and not self._stopping:
-            self._stopping = True
-            self.src.put(self.src.EXIT_EVENT, block=True, timeout=wait_time)
-            elapsed_time = time.time() - start_time
-            wait_time = timeout and max(timeout - elapsed_time, 0)
-        if self.src.EXIT_EVENT.wait(timeout=wait_time):
-            return time.time() - start_time  # time taken to stop
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may 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.
+
+import atexit
+import threading
+import time
+
+from opencensus.common.schedule import Queue, QueueEvent
+from opencensus.ext.azure.common import Options
+from opencensus.trace import execution_context
+
+
+class BaseExporter(object):
+    def __init__(self, **options):
+        options = Options(**options)
+        self.export_interval = options.export_interval
+        self.max_batch_size = options.max_batch_size
+        # TODO: queue should be moved to tracer
+        # too much refactor work, leave to the next PR
+        self._queue = Queue(capacity=options.queue_capacity)
+        # TODO: worker should not be created in the base exporter
+        self._worker = Worker(self._queue, self)
+        self._worker.start()
+        atexit.register(self._worker.stop, options.grace_period)
+
+    # Ideally we don't want to have `emit`
+    # Exporter will have one public method - `export`, which is a blocking
+    # method, running inside worker threads.
+    def emit(self, batch, event=None):
+        raise NotImplementedError  # pragma: NO COVER
+
+    # TODO: we shouldn't have this at the beginning
+    # Tracer should own the queue, exporter shouldn't even know if the
+    # source is a queue or not.
+    # Tracer puts span_data into the queue.
+    # Worker gets span_data from the src (here is the queue) and feed into
+    # the dst (exporter).
+    # Exporter defines the MTU (max_batch_size) and export_interval.
+    # There can be one worker for each queue, or multiple workers for each
+    # queue, or shared workers among queues (e.g. queue for traces, queue
+    # for logs).
+    def export(self, items):
+        self._queue.puts(items, block=False)  # pragma: NO COVER
+
+
+class Worker(threading.Thread):
+    daemon = True
+
+    def __init__(self, src, dst):
+        self.src = src
+        self.dst = dst
+        self._stopping = False
+        super(Worker, self).__init__(
+            name="AzureExporter Worker"
+        )
+
+    def run(self):  # pragma: NO COVER
+        # Indicate that this thread is an exporter thread.
+        # Used to suppress tracking of requests in this thread
+        execution_context.set_is_exporter(True)
+        src = self.src
+        dst = self.dst
+        while True:
+            batch = src.gets(dst.max_batch_size, dst.export_interval)
+            if batch and isinstance(batch[-1], QueueEvent):
+                dst.emit(batch[:-1], event=batch[-1])
+                if batch[-1] is src.EXIT_EVENT:
+                    break
+                else:
+                    continue
+            dst.emit(batch)
+
+    def stop(self, timeout=None):  # pragma: NO COVER
+        start_time = time.time()
+        wait_time = timeout
+        if self.is_alive() and not self._stopping:
+            self._stopping = True
+            self.src.put(self.src.EXIT_EVENT, block=True, timeout=wait_time)
+            elapsed_time = time.time() - start_time
+            wait_time = timeout and max(timeout - elapsed_time, 0)
+        if self.src.EXIT_EVENT.wait(timeout=wait_time):
+            return time.time() - start_time  # time taken to stop

py2docfx/venv/venv1/Lib/site-packages/opencensus/ext/azure/common/processor.py

@@ -1,63 +1,63 @@
-# Copyright 2019, OpenCensus Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may 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.
-
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class ProcessorMixin(object):
-    """ProcessorMixin adds the ability to process telemetry processors
-
-    Telemetry processors are functions that are called before exporting of
-    telemetry to possibly modify the envelope contents.
-    """
-
-    def add_telemetry_processor(self, processor):
-        """Adds telemetry processor to the collection. Telemetry processors
-        will be called one by one before telemetry item is pushed for sending
-        and in the order they were added.
-
-        :param processor: The processor to add.
-        """
-        self._telemetry_processors.append(processor)
-
-    def clear_telemetry_processors(self):
-        """Removes all telemetry processors"""
-        self._telemetry_processors = []
-
-    def apply_telemetry_processors(self, envelopes):
-        """Applies all telemetry processors in the order they were added.
-
-        This function will return the list of envelopes to be exported after
-        each processor has been run sequentially. Individual processors can
-        throw exceptions and fail, but the applying of all telemetry processors
-        will proceed (not fast fail). Processors also return True if envelope
-        should be included for exporting, False otherwise.
-
-        :param envelopes: The envelopes to apply each processor to.
-        """
-        filtered_envelopes = []
-        for envelope in envelopes:
-            accepted = True
-            for processor in self._telemetry_processors:
-                try:
-                    if processor(envelope) is False:
-                        accepted = False
-                        break
-                except Exception as ex:
-                    logger.warning('Telemetry processor failed with: %s.', ex)
-            if accepted:
-                filtered_envelopes.append(envelope)
-        return filtered_envelopes
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may 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.
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ProcessorMixin(object):
+    """ProcessorMixin adds the ability to process telemetry processors
+
+    Telemetry processors are functions that are called before exporting of
+    telemetry to possibly modify the envelope contents.
+    """
+
+    def add_telemetry_processor(self, processor):
+        """Adds telemetry processor to the collection. Telemetry processors
+        will be called one by one before telemetry item is pushed for sending
+        and in the order they were added.
+
+        :param processor: The processor to add.
+        """
+        self._telemetry_processors.append(processor)
+
+    def clear_telemetry_processors(self):
+        """Removes all telemetry processors"""
+        self._telemetry_processors = []
+
+    def apply_telemetry_processors(self, envelopes):
+        """Applies all telemetry processors in the order they were added.
+
+        This function will return the list of envelopes to be exported after
+        each processor has been run sequentially. Individual processors can
+        throw exceptions and fail, but the applying of all telemetry processors
+        will proceed (not fast fail). Processors also return True if envelope
+        should be included for exporting, False otherwise.
+
+        :param envelopes: The envelopes to apply each processor to.
+        """
+        filtered_envelopes = []
+        for envelope in envelopes:
+            accepted = True
+            for processor in self._telemetry_processors:
+                try:
+                    if processor(envelope) is False:
+                        accepted = False
+                        break
+                except Exception as ex:
+                    logger.warning('Telemetry processor failed with: %s.', ex)
+            if accepted:
+                filtered_envelopes.append(envelope)
+        return filtered_envelopes