SolarManager unter Versionsverwaltung
Erster Stand der Hintergrundprozesse, die auf der Synology unter /volume1/homes/wagner/SolarManager laufen: der Manager selbst, die Sammler je Geraet, die MQTT-Bruecke, der Wecker und - neu hinzugezogen - der AutoAction-Runner, der als Hintergrundprozess hierher gehoert und nicht ins Web-Verzeichnis. Zugangsdaten stehen nicht mehr im Quelltext, sondern in config.ini, die nicht mit eingecheckt wird. Vorlage ist config.ini.example, gelesen wird sie von konfig.py. Betroffen waren solarManager.py (Datenbank und Wattpilot), zeit.py, gatherWaterData.py, wecker.py und skoda_testdaten.py, das sich das Passwort bisher aus dem Quelltext eines anderen Moduls herausgesucht hat. Die Kia-Anbindung ist mit dem Fahrzeug entfallen: kiaTest.py, gatherCarData.py und hyundai_kia_connect_api sind nicht mehr dabei, ebenso gatherInverterData.py, auf das nur noch eine auskommentierte Zeile zeigte. Die mitgelieferten Bibliotheken bleiben im Repository - die NAS hat kein pip, sie muessen neben den Skripten liegen. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,506 @@
|
||||
# Copyright The OpenTelemetry 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 collections
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
import threading
|
||||
import typing
|
||||
|
||||
from enum import Enum
|
||||
from os import environ, linesep
|
||||
from time import time_ns
|
||||
from typing import Optional
|
||||
|
||||
from mysql.opentelemetry.context import (
|
||||
_SUPPRESS_INSTRUMENTATION_KEY,
|
||||
Context,
|
||||
attach,
|
||||
detach,
|
||||
set_value,
|
||||
)
|
||||
from mysql.opentelemetry.sdk.environment_variables import (
|
||||
OTEL_BSP_EXPORT_TIMEOUT,
|
||||
OTEL_BSP_MAX_EXPORT_BATCH_SIZE,
|
||||
OTEL_BSP_MAX_QUEUE_SIZE,
|
||||
OTEL_BSP_SCHEDULE_DELAY,
|
||||
)
|
||||
from mysql.opentelemetry.sdk.trace import ReadableSpan, Span, SpanProcessor
|
||||
from mysql.opentelemetry.util._once import Once
|
||||
|
||||
_DEFAULT_SCHEDULE_DELAY_MILLIS = 5000
|
||||
_DEFAULT_MAX_EXPORT_BATCH_SIZE = 512
|
||||
_DEFAULT_EXPORT_TIMEOUT_MILLIS = 30000
|
||||
_DEFAULT_MAX_QUEUE_SIZE = 2048
|
||||
_ENV_VAR_INT_VALUE_ERROR_MESSAGE = (
|
||||
"Unable to parse value for %s as integer. Defaulting to %s."
|
||||
)
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class SpanExportResult(Enum):
|
||||
SUCCESS = 0
|
||||
FAILURE = 1
|
||||
|
||||
|
||||
class SpanExporter:
|
||||
"""Interface for exporting spans.
|
||||
|
||||
Interface to be implemented by services that want to export spans recorded
|
||||
in their own format.
|
||||
|
||||
To export data this MUST be registered to the :class`mysql.opentelemetry.sdk.trace.Tracer` using a
|
||||
`SimpleSpanProcessor` or a `BatchSpanProcessor`.
|
||||
"""
|
||||
|
||||
def export(self, spans: typing.Sequence[ReadableSpan]) -> "SpanExportResult":
|
||||
"""Exports a batch of telemetry data.
|
||||
|
||||
Args:
|
||||
spans: The list of `mysql.opentelemetry.trace.Span` objects to be exported
|
||||
|
||||
Returns:
|
||||
The result of the export
|
||||
"""
|
||||
|
||||
def shutdown(self) -> None:
|
||||
"""Shuts down the exporter.
|
||||
|
||||
Called when the SDK is shut down.
|
||||
"""
|
||||
|
||||
def force_flush(self, timeout_millis: int = 30000) -> bool:
|
||||
"""Hint to ensure that the export of any spans the exporter has received
|
||||
prior to the call to ForceFlush SHOULD be completed as soon as possible, preferably
|
||||
before returning from this method.
|
||||
"""
|
||||
|
||||
|
||||
class SimpleSpanProcessor(SpanProcessor):
|
||||
"""Simple SpanProcessor implementation.
|
||||
|
||||
SimpleSpanProcessor is an implementation of `SpanProcessor` that
|
||||
passes ended spans directly to the configured `SpanExporter`.
|
||||
"""
|
||||
|
||||
def __init__(self, span_exporter: SpanExporter):
|
||||
self.span_exporter = span_exporter
|
||||
|
||||
def on_start(
|
||||
self, span: Span, parent_context: typing.Optional[Context] = None
|
||||
) -> None:
|
||||
pass
|
||||
|
||||
def on_end(self, span: ReadableSpan) -> None:
|
||||
if not span.context.trace_flags.sampled:
|
||||
return
|
||||
token = attach(set_value(_SUPPRESS_INSTRUMENTATION_KEY, True))
|
||||
try:
|
||||
self.span_exporter.export((span,))
|
||||
# pylint: disable=broad-except
|
||||
except Exception:
|
||||
logger.exception("Exception while exporting Span.")
|
||||
detach(token)
|
||||
|
||||
def shutdown(self) -> None:
|
||||
self.span_exporter.shutdown()
|
||||
|
||||
def force_flush(self, timeout_millis: int = 30000) -> bool:
|
||||
# pylint: disable=unused-argument
|
||||
return True
|
||||
|
||||
|
||||
class _FlushRequest:
|
||||
"""Represents a request for the BatchSpanProcessor to flush spans."""
|
||||
|
||||
__slots__ = ["event", "num_spans"]
|
||||
|
||||
def __init__(self):
|
||||
self.event = threading.Event()
|
||||
self.num_spans = 0
|
||||
|
||||
|
||||
_BSP_RESET_ONCE = Once()
|
||||
|
||||
|
||||
class BatchSpanProcessor(SpanProcessor):
|
||||
"""Batch span processor implementation.
|
||||
|
||||
`BatchSpanProcessor` is an implementation of `SpanProcessor` that
|
||||
batches ended spans and pushes them to the configured `SpanExporter`.
|
||||
|
||||
`BatchSpanProcessor` is configurable with the following environment
|
||||
variables which correspond to constructor parameters:
|
||||
|
||||
- :envvar:`OTEL_BSP_SCHEDULE_DELAY`
|
||||
- :envvar:`OTEL_BSP_MAX_QUEUE_SIZE`
|
||||
- :envvar:`OTEL_BSP_MAX_EXPORT_BATCH_SIZE`
|
||||
- :envvar:`OTEL_BSP_EXPORT_TIMEOUT`
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
span_exporter: SpanExporter,
|
||||
max_queue_size: int = None,
|
||||
schedule_delay_millis: float = None,
|
||||
max_export_batch_size: int = None,
|
||||
export_timeout_millis: float = None,
|
||||
):
|
||||
if max_queue_size is None:
|
||||
max_queue_size = BatchSpanProcessor._default_max_queue_size()
|
||||
|
||||
if schedule_delay_millis is None:
|
||||
schedule_delay_millis = BatchSpanProcessor._default_schedule_delay_millis()
|
||||
|
||||
if max_export_batch_size is None:
|
||||
max_export_batch_size = BatchSpanProcessor._default_max_export_batch_size()
|
||||
|
||||
if export_timeout_millis is None:
|
||||
export_timeout_millis = BatchSpanProcessor._default_export_timeout_millis()
|
||||
|
||||
BatchSpanProcessor._validate_arguments(
|
||||
max_queue_size, schedule_delay_millis, max_export_batch_size
|
||||
)
|
||||
|
||||
self.span_exporter = span_exporter
|
||||
self.queue = collections.deque([], max_queue_size) # type: typing.Deque[Span]
|
||||
self.worker_thread = threading.Thread(
|
||||
name="OtelBatchSpanProcessor", target=self.worker, daemon=True
|
||||
)
|
||||
self.condition = threading.Condition(threading.Lock())
|
||||
self._flush_request = None # type: typing.Optional[_FlushRequest]
|
||||
self.schedule_delay_millis = schedule_delay_millis
|
||||
self.max_export_batch_size = max_export_batch_size
|
||||
self.max_queue_size = max_queue_size
|
||||
self.export_timeout_millis = export_timeout_millis
|
||||
self.done = False
|
||||
# flag that indicates that spans are being dropped
|
||||
self._spans_dropped = False
|
||||
# precallocated list to send spans to exporter
|
||||
self.spans_list = [
|
||||
None
|
||||
] * self.max_export_batch_size # type: typing.List[typing.Optional[Span]]
|
||||
self.worker_thread.start()
|
||||
# Only available in *nix since py37.
|
||||
if hasattr(os, "register_at_fork"):
|
||||
os.register_at_fork(
|
||||
after_in_child=self._at_fork_reinit
|
||||
) # pylint: disable=protected-access
|
||||
self._pid = os.getpid()
|
||||
|
||||
def on_start(
|
||||
self, span: Span, parent_context: typing.Optional[Context] = None
|
||||
) -> None:
|
||||
pass
|
||||
|
||||
def on_end(self, span: ReadableSpan) -> None:
|
||||
if self.done:
|
||||
logger.warning("Already shutdown, dropping span.")
|
||||
return
|
||||
if not span.context.trace_flags.sampled:
|
||||
return
|
||||
if self._pid != os.getpid():
|
||||
_BSP_RESET_ONCE.do_once(self._at_fork_reinit)
|
||||
|
||||
if len(self.queue) == self.max_queue_size:
|
||||
if not self._spans_dropped:
|
||||
logger.warning("Queue is full, likely spans will be dropped.")
|
||||
self._spans_dropped = True
|
||||
|
||||
self.queue.appendleft(span)
|
||||
|
||||
if len(self.queue) >= self.max_export_batch_size:
|
||||
with self.condition:
|
||||
self.condition.notify()
|
||||
|
||||
def _at_fork_reinit(self):
|
||||
self.condition = threading.Condition(threading.Lock())
|
||||
self.queue.clear()
|
||||
|
||||
# worker_thread is local to a process, only the thread that issued fork continues
|
||||
# to exist. A new worker thread must be started in child process.
|
||||
self.worker_thread = threading.Thread(
|
||||
name="OtelBatchSpanProcessor", target=self.worker, daemon=True
|
||||
)
|
||||
self.worker_thread.start()
|
||||
self._pid = os.getpid()
|
||||
|
||||
def worker(self):
|
||||
timeout = self.schedule_delay_millis / 1e3
|
||||
flush_request = None # type: typing.Optional[_FlushRequest]
|
||||
while not self.done:
|
||||
with self.condition:
|
||||
if self.done:
|
||||
# done flag may have changed, avoid waiting
|
||||
break
|
||||
flush_request = self._get_and_unset_flush_request()
|
||||
if (
|
||||
len(self.queue) < self.max_export_batch_size
|
||||
and flush_request is None
|
||||
):
|
||||
self.condition.wait(timeout)
|
||||
flush_request = self._get_and_unset_flush_request()
|
||||
if not self.queue:
|
||||
# spurious notification, let's wait again, reset timeout
|
||||
timeout = self.schedule_delay_millis / 1e3
|
||||
self._notify_flush_request_finished(flush_request)
|
||||
flush_request = None
|
||||
continue
|
||||
if self.done:
|
||||
# missing spans will be sent when calling flush
|
||||
break
|
||||
|
||||
# subtract the duration of this export call to the next timeout
|
||||
start = time_ns()
|
||||
self._export(flush_request)
|
||||
end = time_ns()
|
||||
duration = (end - start) / 1e9
|
||||
timeout = self.schedule_delay_millis / 1e3 - duration
|
||||
|
||||
self._notify_flush_request_finished(flush_request)
|
||||
flush_request = None
|
||||
|
||||
# there might have been a new flush request while export was running
|
||||
# and before the done flag switched to true
|
||||
with self.condition:
|
||||
shutdown_flush_request = self._get_and_unset_flush_request()
|
||||
|
||||
# be sure that all spans are sent
|
||||
self._drain_queue()
|
||||
self._notify_flush_request_finished(flush_request)
|
||||
self._notify_flush_request_finished(shutdown_flush_request)
|
||||
|
||||
def _get_and_unset_flush_request(
|
||||
self,
|
||||
) -> typing.Optional[_FlushRequest]:
|
||||
"""Returns the current flush request and makes it invisible to the
|
||||
worker thread for subsequent calls.
|
||||
"""
|
||||
flush_request = self._flush_request
|
||||
self._flush_request = None
|
||||
if flush_request is not None:
|
||||
flush_request.num_spans = len(self.queue)
|
||||
return flush_request
|
||||
|
||||
@staticmethod
|
||||
def _notify_flush_request_finished(
|
||||
flush_request: typing.Optional[_FlushRequest],
|
||||
):
|
||||
"""Notifies the flush initiator(s) waiting on the given request/event
|
||||
that the flush operation was finished.
|
||||
"""
|
||||
if flush_request is not None:
|
||||
flush_request.event.set()
|
||||
|
||||
def _get_or_create_flush_request(self) -> _FlushRequest:
|
||||
"""Either returns the current active flush event or creates a new one.
|
||||
|
||||
The flush event will be visible and read by the worker thread before an
|
||||
export operation starts. Callers of a flush operation may wait on the
|
||||
returned event to be notified when the flush/export operation was
|
||||
finished.
|
||||
|
||||
This method is not thread-safe, i.e. callers need to take care about
|
||||
synchronization/locking.
|
||||
"""
|
||||
if self._flush_request is None:
|
||||
self._flush_request = _FlushRequest()
|
||||
return self._flush_request
|
||||
|
||||
def _export(self, flush_request: typing.Optional[_FlushRequest]):
|
||||
"""Exports spans considering the given flush_request.
|
||||
|
||||
In case of a given flush_requests spans are exported in batches until
|
||||
the number of exported spans reached or exceeded the number of spans in
|
||||
the flush request.
|
||||
In no flush_request was given at most max_export_batch_size spans are
|
||||
exported.
|
||||
"""
|
||||
if not flush_request:
|
||||
self._export_batch()
|
||||
return
|
||||
|
||||
num_spans = flush_request.num_spans
|
||||
while self.queue:
|
||||
num_exported = self._export_batch()
|
||||
num_spans -= num_exported
|
||||
|
||||
if num_spans <= 0:
|
||||
break
|
||||
|
||||
def _export_batch(self) -> int:
|
||||
"""Exports at most max_export_batch_size spans and returns the number of
|
||||
exported spans.
|
||||
"""
|
||||
idx = 0
|
||||
# currently only a single thread acts as consumer, so queue.pop() will
|
||||
# not raise an exception
|
||||
while idx < self.max_export_batch_size and self.queue:
|
||||
self.spans_list[idx] = self.queue.pop()
|
||||
idx += 1
|
||||
token = attach(set_value(_SUPPRESS_INSTRUMENTATION_KEY, True))
|
||||
try:
|
||||
# Ignore type b/c the Optional[None]+slicing is too "clever"
|
||||
# for mypy
|
||||
self.span_exporter.export(self.spans_list[:idx]) # type: ignore
|
||||
except Exception: # pylint: disable=broad-except
|
||||
logger.exception("Exception while exporting Span batch.")
|
||||
detach(token)
|
||||
|
||||
# clean up list
|
||||
for index in range(idx):
|
||||
self.spans_list[index] = None
|
||||
return idx
|
||||
|
||||
def _drain_queue(self):
|
||||
"""Export all elements until queue is empty.
|
||||
|
||||
Can only be called from the worker thread context because it invokes
|
||||
`export` that is not thread safe.
|
||||
"""
|
||||
while self.queue:
|
||||
self._export_batch()
|
||||
|
||||
def force_flush(self, timeout_millis: int = None) -> bool:
|
||||
if timeout_millis is None:
|
||||
timeout_millis = self.export_timeout_millis
|
||||
|
||||
if self.done:
|
||||
logger.warning("Already shutdown, ignoring call to force_flush().")
|
||||
return True
|
||||
|
||||
with self.condition:
|
||||
flush_request = self._get_or_create_flush_request()
|
||||
# signal the worker thread to flush and wait for it to finish
|
||||
self.condition.notify_all()
|
||||
|
||||
# wait for token to be processed
|
||||
ret = flush_request.event.wait(timeout_millis / 1e3)
|
||||
if not ret:
|
||||
logger.warning("Timeout was exceeded in force_flush().")
|
||||
return ret
|
||||
|
||||
def shutdown(self) -> None:
|
||||
# signal the worker thread to finish and then wait for it
|
||||
self.done = True
|
||||
with self.condition:
|
||||
self.condition.notify_all()
|
||||
self.worker_thread.join()
|
||||
self.span_exporter.shutdown()
|
||||
|
||||
@staticmethod
|
||||
def _default_max_queue_size():
|
||||
try:
|
||||
return int(environ.get(OTEL_BSP_MAX_QUEUE_SIZE, _DEFAULT_MAX_QUEUE_SIZE))
|
||||
except ValueError:
|
||||
logger.exception(
|
||||
_ENV_VAR_INT_VALUE_ERROR_MESSAGE,
|
||||
OTEL_BSP_MAX_QUEUE_SIZE,
|
||||
_DEFAULT_MAX_QUEUE_SIZE,
|
||||
)
|
||||
return _DEFAULT_MAX_QUEUE_SIZE
|
||||
|
||||
@staticmethod
|
||||
def _default_schedule_delay_millis():
|
||||
try:
|
||||
return int(
|
||||
environ.get(OTEL_BSP_SCHEDULE_DELAY, _DEFAULT_SCHEDULE_DELAY_MILLIS)
|
||||
)
|
||||
except ValueError:
|
||||
logger.exception(
|
||||
_ENV_VAR_INT_VALUE_ERROR_MESSAGE,
|
||||
OTEL_BSP_SCHEDULE_DELAY,
|
||||
_DEFAULT_SCHEDULE_DELAY_MILLIS,
|
||||
)
|
||||
return _DEFAULT_SCHEDULE_DELAY_MILLIS
|
||||
|
||||
@staticmethod
|
||||
def _default_max_export_batch_size():
|
||||
try:
|
||||
return int(
|
||||
environ.get(
|
||||
OTEL_BSP_MAX_EXPORT_BATCH_SIZE,
|
||||
_DEFAULT_MAX_EXPORT_BATCH_SIZE,
|
||||
)
|
||||
)
|
||||
except ValueError:
|
||||
logger.exception(
|
||||
_ENV_VAR_INT_VALUE_ERROR_MESSAGE,
|
||||
OTEL_BSP_MAX_EXPORT_BATCH_SIZE,
|
||||
_DEFAULT_MAX_EXPORT_BATCH_SIZE,
|
||||
)
|
||||
return _DEFAULT_MAX_EXPORT_BATCH_SIZE
|
||||
|
||||
@staticmethod
|
||||
def _default_export_timeout_millis():
|
||||
try:
|
||||
return int(
|
||||
environ.get(OTEL_BSP_EXPORT_TIMEOUT, _DEFAULT_EXPORT_TIMEOUT_MILLIS)
|
||||
)
|
||||
except ValueError:
|
||||
logger.exception(
|
||||
_ENV_VAR_INT_VALUE_ERROR_MESSAGE,
|
||||
OTEL_BSP_EXPORT_TIMEOUT,
|
||||
_DEFAULT_EXPORT_TIMEOUT_MILLIS,
|
||||
)
|
||||
return _DEFAULT_EXPORT_TIMEOUT_MILLIS
|
||||
|
||||
@staticmethod
|
||||
def _validate_arguments(
|
||||
max_queue_size, schedule_delay_millis, max_export_batch_size
|
||||
):
|
||||
if max_queue_size <= 0:
|
||||
raise ValueError("max_queue_size must be a positive integer.")
|
||||
|
||||
if schedule_delay_millis <= 0:
|
||||
raise ValueError("schedule_delay_millis must be positive.")
|
||||
|
||||
if max_export_batch_size <= 0:
|
||||
raise ValueError("max_export_batch_size must be a positive integer.")
|
||||
|
||||
if max_export_batch_size > max_queue_size:
|
||||
raise ValueError(
|
||||
"max_export_batch_size must be less than or equal to max_queue_size."
|
||||
)
|
||||
|
||||
|
||||
class ConsoleSpanExporter(SpanExporter):
|
||||
"""Implementation of :class:`SpanExporter` that prints spans to the
|
||||
console.
|
||||
|
||||
This class can be used for diagnostic purposes. It prints the exported
|
||||
spans to the console STDOUT.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
service_name: Optional[str] = None,
|
||||
out: typing.IO = sys.stdout,
|
||||
formatter: typing.Callable[[ReadableSpan], str] = lambda span: span.to_json()
|
||||
+ linesep,
|
||||
):
|
||||
self.out = out
|
||||
self.formatter = formatter
|
||||
self.service_name = service_name
|
||||
|
||||
def export(self, spans: typing.Sequence[ReadableSpan]) -> SpanExportResult:
|
||||
for span in spans:
|
||||
self.out.write(self.formatter(span))
|
||||
self.out.flush()
|
||||
return SpanExportResult.SUCCESS
|
||||
|
||||
def force_flush(self, timeout_millis: int = 30000) -> bool:
|
||||
return True
|
||||
@@ -0,0 +1,61 @@
|
||||
# Copyright The OpenTelemetry 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 threading
|
||||
import typing
|
||||
|
||||
from mysql.opentelemetry.sdk.trace import ReadableSpan
|
||||
from mysql.opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
|
||||
|
||||
|
||||
class InMemorySpanExporter(SpanExporter):
|
||||
"""Implementation of :class:`.SpanExporter` that stores spans in memory.
|
||||
|
||||
This class can be used for testing purposes. It stores the exported spans
|
||||
in a list in memory that can be retrieved using the
|
||||
:func:`.get_finished_spans` method.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self._finished_spans = []
|
||||
self._stopped = False
|
||||
self._lock = threading.Lock()
|
||||
|
||||
def clear(self):
|
||||
"""Clear list of collected spans."""
|
||||
with self._lock:
|
||||
self._finished_spans.clear()
|
||||
|
||||
def get_finished_spans(self):
|
||||
"""Get list of collected spans."""
|
||||
with self._lock:
|
||||
return tuple(self._finished_spans)
|
||||
|
||||
def export(self, spans: typing.Sequence[ReadableSpan]) -> SpanExportResult:
|
||||
"""Stores a list of spans in memory."""
|
||||
if self._stopped:
|
||||
return SpanExportResult.FAILURE
|
||||
with self._lock:
|
||||
self._finished_spans.extend(spans)
|
||||
return SpanExportResult.SUCCESS
|
||||
|
||||
def shutdown(self):
|
||||
"""Shut downs the exporter.
|
||||
|
||||
Calls to export after the exporter has been shut down will fail.
|
||||
"""
|
||||
self._stopped = True
|
||||
|
||||
def force_flush(self, timeout_millis: int = 30000) -> bool:
|
||||
return True
|
||||
@@ -0,0 +1,52 @@
|
||||
# Copyright The OpenTelemetry 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 abc
|
||||
import random
|
||||
|
||||
|
||||
class IdGenerator(abc.ABC):
|
||||
@abc.abstractmethod
|
||||
def generate_span_id(self) -> int:
|
||||
"""Get a new span ID.
|
||||
|
||||
Returns:
|
||||
A 64-bit int for use as a span ID
|
||||
"""
|
||||
|
||||
@abc.abstractmethod
|
||||
def generate_trace_id(self) -> int:
|
||||
"""Get a new trace ID.
|
||||
|
||||
Implementations should at least make the 64 least significant bits
|
||||
uniformly random. Samplers like the `TraceIdRatioBased` sampler rely on
|
||||
this randomness to make sampling decisions.
|
||||
|
||||
See `the specification on TraceIdRatioBased <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/sdk.md#traceidratiobased>`_.
|
||||
|
||||
Returns:
|
||||
A 128-bit int for use as a trace ID
|
||||
"""
|
||||
|
||||
|
||||
class RandomIdGenerator(IdGenerator):
|
||||
"""The default ID generator for TracerProvider which randomly generates all
|
||||
bits when generating IDs.
|
||||
"""
|
||||
|
||||
def generate_span_id(self) -> int:
|
||||
return random.getrandbits(64)
|
||||
|
||||
def generate_trace_id(self) -> int:
|
||||
return random.getrandbits(128)
|
||||
@@ -0,0 +1,447 @@
|
||||
# Copyright The OpenTelemetry 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.
|
||||
|
||||
"""
|
||||
For general information about sampling, see `the specification <https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/sdk.md#sampling>`_.
|
||||
|
||||
OpenTelemetry provides two types of samplers:
|
||||
|
||||
- `StaticSampler`
|
||||
- `TraceIdRatioBased`
|
||||
|
||||
A `StaticSampler` always returns the same sampling result regardless of the conditions. Both possible StaticSamplers are already created:
|
||||
|
||||
- Always sample spans: ALWAYS_ON
|
||||
- Never sample spans: ALWAYS_OFF
|
||||
|
||||
A `TraceIdRatioBased` sampler makes a random sampling result based on the sampling probability given.
|
||||
|
||||
If the span being sampled has a parent, `ParentBased` will respect the parent delegate sampler. Otherwise, it returns the sampling result from the given root sampler.
|
||||
|
||||
Currently, sampling results are always made during the creation of the span. However, this might not always be the case in the future (see `OTEP #115 <https://github.com/open-telemetry/oteps/pull/115>`_).
|
||||
|
||||
Custom samplers can be created by subclassing `Sampler` and implementing `Sampler.should_sample` as well as `Sampler.get_description`.
|
||||
|
||||
Samplers are able to modify the `mysql.opentelemetry.trace.span.TraceState` of the parent of the span being created. For custom samplers, it is suggested to implement `Sampler.should_sample` to utilize the
|
||||
parent span context's `mysql.opentelemetry.trace.span.TraceState` and pass into the `SamplingResult` instead of the explicit trace_state field passed into the parameter of `Sampler.should_sample`.
|
||||
|
||||
To use a sampler, pass it into the tracer provider constructor. For example:
|
||||
|
||||
.. code:: python
|
||||
|
||||
from opentelemetry import trace
|
||||
from mysql.opentelemetry.sdk.trace import TracerProvider
|
||||
from mysql.opentelemetry.sdk.trace.export import (
|
||||
ConsoleSpanExporter,
|
||||
SimpleSpanProcessor,
|
||||
)
|
||||
from mysql.opentelemetry.sdk.trace.sampling import TraceIdRatioBased
|
||||
|
||||
# sample 1 in every 1000 traces
|
||||
sampler = TraceIdRatioBased(1/1000)
|
||||
|
||||
# set the sampler onto the global tracer provider
|
||||
trace.set_tracer_provider(TracerProvider(sampler=sampler))
|
||||
|
||||
# set up an exporter for sampled spans
|
||||
trace.get_tracer_provider().add_span_processor(
|
||||
SimpleSpanProcessor(ConsoleSpanExporter())
|
||||
)
|
||||
|
||||
# created spans will now be sampled by the TraceIdRatioBased sampler
|
||||
with trace.get_tracer(__name__).start_as_current_span("Test Span"):
|
||||
...
|
||||
|
||||
The tracer sampler can also be configured via environment variables ``OTEL_TRACES_SAMPLER`` and ``OTEL_TRACES_SAMPLER_ARG`` (only if applicable).
|
||||
The list of built-in values for ``OTEL_TRACES_SAMPLER`` are:
|
||||
|
||||
* always_on - Sampler that always samples spans, regardless of the parent span's sampling decision.
|
||||
* always_off - Sampler that never samples spans, regardless of the parent span's sampling decision.
|
||||
* traceidratio - Sampler that samples probabalistically based on rate.
|
||||
* parentbased_always_on - (default) Sampler that respects its parent span's sampling decision, but otherwise always samples.
|
||||
* parentbased_always_off - Sampler that respects its parent span's sampling decision, but otherwise never samples.
|
||||
* parentbased_traceidratio - Sampler that respects its parent span's sampling decision, but otherwise samples probabalistically based on rate.
|
||||
|
||||
Sampling probability can be set with ``OTEL_TRACES_SAMPLER_ARG`` if the sampler is traceidratio or parentbased_traceidratio. Rate must be in the range [0.0,1.0]. When not provided rate will be set to
|
||||
1.0 (maximum rate possible).
|
||||
|
||||
Prev example but with environment variables. Please make sure to set the env ``OTEL_TRACES_SAMPLER=traceidratio`` and ``OTEL_TRACES_SAMPLER_ARG=0.001``.
|
||||
|
||||
.. code:: python
|
||||
|
||||
from opentelemetry import trace
|
||||
from mysql.opentelemetry.sdk.trace import TracerProvider
|
||||
from mysql.opentelemetry.sdk.trace.export import (
|
||||
ConsoleSpanExporter,
|
||||
SimpleSpanProcessor,
|
||||
)
|
||||
|
||||
trace.set_tracer_provider(TracerProvider())
|
||||
|
||||
# set up an exporter for sampled spans
|
||||
trace.get_tracer_provider().add_span_processor(
|
||||
SimpleSpanProcessor(ConsoleSpanExporter())
|
||||
)
|
||||
|
||||
# created spans will now be sampled by the TraceIdRatioBased sampler with rate 1/1000.
|
||||
with trace.get_tracer(__name__).start_as_current_span("Test Span"):
|
||||
...
|
||||
|
||||
When utilizing a configurator, you can configure a custom sampler. In order to create a configurable custom sampler, create an entry point for the custom sampler
|
||||
factory method or function under the entry point group, ``opentelemetry_traces_sampler``. The custom sampler factory method must be of type ``Callable[[str], Sampler]``, taking a single string argument and
|
||||
returning a Sampler object. The single input will come from the string value of the ``OTEL_TRACES_SAMPLER_ARG`` environment variable. If ``OTEL_TRACES_SAMPLER_ARG`` is not configured, the input will
|
||||
be an empty string. For example:
|
||||
|
||||
.. code:: python
|
||||
|
||||
setup(
|
||||
...
|
||||
entry_points={
|
||||
...
|
||||
"opentelemetry_traces_sampler": [
|
||||
"custom_sampler_name = path.to.sampler.factory.method:CustomSamplerFactory.get_sampler"
|
||||
]
|
||||
}
|
||||
)
|
||||
# ...
|
||||
class CustomRatioSampler(Sampler):
|
||||
def __init__(rate):
|
||||
# ...
|
||||
# ...
|
||||
class CustomSamplerFactory:
|
||||
@staticmethod
|
||||
get_sampler(sampler_argument):
|
||||
try:
|
||||
rate = float(sampler_argument)
|
||||
return CustomSampler(rate)
|
||||
except ValueError: # In case argument is empty string.
|
||||
return CustomSampler(0.5)
|
||||
|
||||
In order to configure you application with a custom sampler's entry point, set the ``OTEL_TRACES_SAMPLER`` environment variable to the key name of the entry point. For example, to configured the
|
||||
above sampler, set ``OTEL_TRACES_SAMPLER=custom_sampler_name`` and ``OTEL_TRACES_SAMPLER_ARG=0.5``.
|
||||
"""
|
||||
import abc
|
||||
import enum
|
||||
import os
|
||||
|
||||
from logging import getLogger
|
||||
from types import MappingProxyType
|
||||
from typing import Optional, Sequence
|
||||
|
||||
# pylint: disable=unused-import
|
||||
from mysql.opentelemetry.context import Context
|
||||
from mysql.opentelemetry.sdk.environment_variables import (
|
||||
OTEL_TRACES_SAMPLER,
|
||||
OTEL_TRACES_SAMPLER_ARG,
|
||||
)
|
||||
from mysql.opentelemetry.trace import Link, SpanKind, get_current_span
|
||||
from mysql.opentelemetry.trace.span import TraceState
|
||||
from mysql.opentelemetry.util.types import Attributes
|
||||
|
||||
_logger = getLogger(__name__)
|
||||
|
||||
|
||||
class Decision(enum.Enum):
|
||||
# IsRecording() == false, span will not be recorded and all events and attributes will be dropped.
|
||||
DROP = 0
|
||||
# IsRecording() == true, but Sampled flag MUST NOT be set.
|
||||
RECORD_ONLY = 1
|
||||
# IsRecording() == true AND Sampled flag` MUST be set.
|
||||
RECORD_AND_SAMPLE = 2
|
||||
|
||||
def is_recording(self):
|
||||
return self in (Decision.RECORD_ONLY, Decision.RECORD_AND_SAMPLE)
|
||||
|
||||
def is_sampled(self):
|
||||
return self is Decision.RECORD_AND_SAMPLE
|
||||
|
||||
|
||||
class SamplingResult:
|
||||
"""A sampling result as applied to a newly-created Span.
|
||||
|
||||
Args:
|
||||
decision: A sampling decision based off of whether the span is recorded
|
||||
and the sampled flag in trace flags in the span context.
|
||||
attributes: Attributes to add to the `mysql.opentelemetry.trace.Span`.
|
||||
trace_state: The tracestate used for the `mysql.opentelemetry.trace.Span`.
|
||||
Could possibly have been modified by the sampler.
|
||||
"""
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f"{type(self).__name__}({str(self.decision)}, attributes={str(self.attributes)})"
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
decision: Decision,
|
||||
attributes: "Attributes" = None,
|
||||
trace_state: "TraceState" = None,
|
||||
) -> None:
|
||||
self.decision = decision
|
||||
if attributes is None:
|
||||
self.attributes = MappingProxyType({})
|
||||
else:
|
||||
self.attributes = MappingProxyType(attributes)
|
||||
self.trace_state = trace_state
|
||||
|
||||
|
||||
class Sampler(abc.ABC):
|
||||
@abc.abstractmethod
|
||||
def should_sample(
|
||||
self,
|
||||
parent_context: Optional["Context"],
|
||||
trace_id: int,
|
||||
name: str,
|
||||
kind: SpanKind = None,
|
||||
attributes: Attributes = None,
|
||||
links: Sequence["Link"] = None,
|
||||
trace_state: "TraceState" = None,
|
||||
) -> "SamplingResult":
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def get_description(self) -> str:
|
||||
pass
|
||||
|
||||
|
||||
class StaticSampler(Sampler):
|
||||
"""Sampler that always returns the same decision."""
|
||||
|
||||
def __init__(self, decision: "Decision"):
|
||||
self._decision = decision
|
||||
|
||||
def should_sample(
|
||||
self,
|
||||
parent_context: Optional["Context"],
|
||||
trace_id: int,
|
||||
name: str,
|
||||
kind: SpanKind = None,
|
||||
attributes: Attributes = None,
|
||||
links: Sequence["Link"] = None,
|
||||
trace_state: "TraceState" = None,
|
||||
) -> "SamplingResult":
|
||||
if self._decision is Decision.DROP:
|
||||
attributes = None
|
||||
return SamplingResult(
|
||||
self._decision,
|
||||
attributes,
|
||||
_get_parent_trace_state(parent_context),
|
||||
)
|
||||
|
||||
def get_description(self) -> str:
|
||||
if self._decision is Decision.DROP:
|
||||
return "AlwaysOffSampler"
|
||||
return "AlwaysOnSampler"
|
||||
|
||||
|
||||
ALWAYS_OFF = StaticSampler(Decision.DROP)
|
||||
"""Sampler that never samples spans, regardless of the parent span's sampling decision."""
|
||||
|
||||
ALWAYS_ON = StaticSampler(Decision.RECORD_AND_SAMPLE)
|
||||
"""Sampler that always samples spans, regardless of the parent span's sampling decision."""
|
||||
|
||||
|
||||
class TraceIdRatioBased(Sampler):
|
||||
"""
|
||||
Sampler that makes sampling decisions probabilistically based on `rate`.
|
||||
|
||||
Args:
|
||||
rate: Probability (between 0 and 1) that a span will be sampled
|
||||
"""
|
||||
|
||||
def __init__(self, rate: float):
|
||||
if rate < 0.0 or rate > 1.0:
|
||||
raise ValueError("Probability must be in range [0.0, 1.0].")
|
||||
self._rate = rate
|
||||
self._bound = self.get_bound_for_rate(self._rate)
|
||||
|
||||
# For compatibility with 64 bit trace IDs, the sampler checks the 64
|
||||
# low-order bits of the trace ID to decide whether to sample a given trace.
|
||||
TRACE_ID_LIMIT = (1 << 64) - 1
|
||||
|
||||
@classmethod
|
||||
def get_bound_for_rate(cls, rate: float) -> int:
|
||||
return round(rate * (cls.TRACE_ID_LIMIT + 1))
|
||||
|
||||
@property
|
||||
def rate(self) -> float:
|
||||
return self._rate
|
||||
|
||||
@property
|
||||
def bound(self) -> int:
|
||||
return self._bound
|
||||
|
||||
def should_sample(
|
||||
self,
|
||||
parent_context: Optional["Context"],
|
||||
trace_id: int,
|
||||
name: str,
|
||||
kind: SpanKind = None,
|
||||
attributes: Attributes = None,
|
||||
links: Sequence["Link"] = None,
|
||||
trace_state: "TraceState" = None,
|
||||
) -> "SamplingResult":
|
||||
decision = Decision.DROP
|
||||
if trace_id & self.TRACE_ID_LIMIT < self.bound:
|
||||
decision = Decision.RECORD_AND_SAMPLE
|
||||
if decision is Decision.DROP:
|
||||
attributes = None
|
||||
return SamplingResult(
|
||||
decision,
|
||||
attributes,
|
||||
_get_parent_trace_state(parent_context),
|
||||
)
|
||||
|
||||
def get_description(self) -> str:
|
||||
return f"TraceIdRatioBased{{{self._rate}}}"
|
||||
|
||||
|
||||
class ParentBased(Sampler):
|
||||
"""
|
||||
If a parent is set, applies the respective delegate sampler.
|
||||
Otherwise, uses the root provided at initialization to make a
|
||||
decision.
|
||||
|
||||
Args:
|
||||
root: Sampler called for spans with no parent (root spans).
|
||||
remote_parent_sampled: Sampler called for a remote sampled parent.
|
||||
remote_parent_not_sampled: Sampler called for a remote parent that is
|
||||
not sampled.
|
||||
local_parent_sampled: Sampler called for a local sampled parent.
|
||||
local_parent_not_sampled: Sampler called for a local parent that is
|
||||
not sampled.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
root: Sampler,
|
||||
remote_parent_sampled: Sampler = ALWAYS_ON,
|
||||
remote_parent_not_sampled: Sampler = ALWAYS_OFF,
|
||||
local_parent_sampled: Sampler = ALWAYS_ON,
|
||||
local_parent_not_sampled: Sampler = ALWAYS_OFF,
|
||||
):
|
||||
self._root = root
|
||||
self._remote_parent_sampled = remote_parent_sampled
|
||||
self._remote_parent_not_sampled = remote_parent_not_sampled
|
||||
self._local_parent_sampled = local_parent_sampled
|
||||
self._local_parent_not_sampled = local_parent_not_sampled
|
||||
|
||||
def should_sample(
|
||||
self,
|
||||
parent_context: Optional["Context"],
|
||||
trace_id: int,
|
||||
name: str,
|
||||
kind: SpanKind = None,
|
||||
attributes: Attributes = None,
|
||||
links: Sequence["Link"] = None,
|
||||
trace_state: "TraceState" = None,
|
||||
) -> "SamplingResult":
|
||||
parent_span_context = get_current_span(parent_context).get_span_context()
|
||||
# default to the root sampler
|
||||
sampler = self._root
|
||||
# respect the sampling and remote flag of the parent if present
|
||||
if parent_span_context is not None and parent_span_context.is_valid:
|
||||
if parent_span_context.is_remote:
|
||||
if parent_span_context.trace_flags.sampled:
|
||||
sampler = self._remote_parent_sampled
|
||||
else:
|
||||
sampler = self._remote_parent_not_sampled
|
||||
else:
|
||||
if parent_span_context.trace_flags.sampled:
|
||||
sampler = self._local_parent_sampled
|
||||
else:
|
||||
sampler = self._local_parent_not_sampled
|
||||
|
||||
return sampler.should_sample(
|
||||
parent_context=parent_context,
|
||||
trace_id=trace_id,
|
||||
name=name,
|
||||
kind=kind,
|
||||
attributes=attributes,
|
||||
links=links,
|
||||
)
|
||||
|
||||
def get_description(self):
|
||||
return f"ParentBased{{root:{self._root.get_description()},remoteParentSampled:{self._remote_parent_sampled.get_description()},remoteParentNotSampled:{self._remote_parent_not_sampled.get_description()},localParentSampled:{self._local_parent_sampled.get_description()},localParentNotSampled:{self._local_parent_not_sampled.get_description()}}}"
|
||||
|
||||
|
||||
DEFAULT_OFF = ParentBased(ALWAYS_OFF)
|
||||
"""Sampler that respects its parent span's sampling decision, but otherwise never samples."""
|
||||
|
||||
DEFAULT_ON = ParentBased(ALWAYS_ON)
|
||||
"""Sampler that respects its parent span's sampling decision, but otherwise always samples."""
|
||||
|
||||
|
||||
class ParentBasedTraceIdRatio(ParentBased):
|
||||
"""
|
||||
Sampler that respects its parent span's sampling decision, but otherwise
|
||||
samples probabalistically based on `rate`.
|
||||
"""
|
||||
|
||||
def __init__(self, rate: float):
|
||||
root = TraceIdRatioBased(rate=rate)
|
||||
super().__init__(root=root)
|
||||
|
||||
|
||||
class _AlwaysOff(StaticSampler):
|
||||
def __init__(self, _):
|
||||
super().__init__(Decision.DROP)
|
||||
|
||||
|
||||
class _AlwaysOn(StaticSampler):
|
||||
def __init__(self, _):
|
||||
super().__init__(Decision.RECORD_AND_SAMPLE)
|
||||
|
||||
|
||||
class _ParentBasedAlwaysOff(ParentBased):
|
||||
def __init__(self, _):
|
||||
super().__init__(ALWAYS_OFF)
|
||||
|
||||
|
||||
class _ParentBasedAlwaysOn(ParentBased):
|
||||
def __init__(self, _):
|
||||
super().__init__(ALWAYS_ON)
|
||||
|
||||
|
||||
_KNOWN_SAMPLERS = {
|
||||
"always_on": ALWAYS_ON,
|
||||
"always_off": ALWAYS_OFF,
|
||||
"parentbased_always_on": DEFAULT_ON,
|
||||
"parentbased_always_off": DEFAULT_OFF,
|
||||
"traceidratio": TraceIdRatioBased,
|
||||
"parentbased_traceidratio": ParentBasedTraceIdRatio,
|
||||
}
|
||||
|
||||
|
||||
def _get_from_env_or_default() -> Sampler:
|
||||
trace_sampler = os.getenv(OTEL_TRACES_SAMPLER, "parentbased_always_on").lower()
|
||||
if trace_sampler not in _KNOWN_SAMPLERS:
|
||||
_logger.warning("Couldn't recognize sampler %s.", trace_sampler)
|
||||
trace_sampler = "parentbased_always_on"
|
||||
|
||||
if trace_sampler in ("traceidratio", "parentbased_traceidratio"):
|
||||
try:
|
||||
rate = float(os.getenv(OTEL_TRACES_SAMPLER_ARG))
|
||||
except (ValueError, TypeError):
|
||||
_logger.warning("Could not convert TRACES_SAMPLER_ARG to float.")
|
||||
rate = 1.0
|
||||
return _KNOWN_SAMPLERS[trace_sampler](rate)
|
||||
|
||||
return _KNOWN_SAMPLERS[trace_sampler]
|
||||
|
||||
|
||||
def _get_parent_trace_state(parent_context) -> Optional["TraceState"]:
|
||||
parent_span_context = get_current_span(parent_context).get_span_context()
|
||||
if parent_span_context is None or not parent_span_context.is_valid:
|
||||
return None
|
||||
return parent_span_context.trace_state
|
||||
Reference in New Issue
Block a user