diff --git a/.github/workflows/main-rc.yml b/.github/workflows/main-rc.yml index cf7858e..be299a5 100644 --- a/.github/workflows/main-rc.yml +++ b/.github/workflows/main-rc.yml @@ -31,3 +31,33 @@ jobs: with: user: __token__ password: ${{ secrets.PYPI_TOKEN }} + + deploy-k8s: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + - name: Set up Python + uses: actions/setup-python@v2 + with: + python-version: '3.x' + - name: Install dependencies + run: | + echo "Building middleware-io-k8s (HTTP exporter)..." + cp pyproject-k8s.toml pyproject.toml + cat pyproject.toml + pip install -r dev-requirements.txt + pip install setuptools wheel build twine + - name: Build and publish + env: + TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} + TWINE_PASSWORD: ${{ secrets.PYPI_ORG_PWD }} + run: | + python -m build + twine upload dist/* + - name: Publish a Python distribution to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + user: __token__ + password: ${{ secrets.PYPI_ORG_PWD }} diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 7a79689..915becd 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -43,3 +43,43 @@ jobs: Release ${{ github.ref }} draft: false prerelease: false + deploy-k8s: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + - name: Set up Python + uses: actions/setup-python@v2 + with: + python-version: '3.x' + - name: Install dependencies + run: | + cp pyproject-k8s.toml pyproject.toml + cat pyproject.toml + pip install -r dev-requirements.txt + pip install setuptools wheel build twine + - name: Build and publish + env: + TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} + TWINE_PASSWORD: ${{ secrets.PYPI_ORG_PWD }} + run: | + python -m build + twine upload dist/* + - name: Publish a Python distribution to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + user: __token__ + password: ${{ secrets.PYPI_ORG_PWD }} + - name: Create Release + id: create_release + uses: actions/create-release@v1 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + with: + tag_name: ${{ github.ref }} + release_name: Release K8s ${{ github.ref }} + body: | + Release K8s ${{ github.ref }} + draft: false + prerelease: false diff --git a/middleware/distro.py b/middleware/distro.py index a495f41..9d4d4be 100644 --- a/middleware/distro.py +++ b/middleware/distro.py @@ -8,7 +8,12 @@ import pkg_resources from opentelemetry.instrumentation.distro import BaseDistro -from middleware.metrics import create_meter_provider +try: + from middleware.metrics import create_meter_provider + PSUTIL_AVAILABLE = True +except ImportError: + PSUTIL_AVAILABLE = False + from middleware.options import MWOptions, parse_bool from middleware.resource import create_resource from middleware.trace import create_tracer_provider @@ -80,7 +85,10 @@ def mw_tracker_internal( if options.collect_traces: create_tracer_provider(options, resource) if options.collect_metrics: - create_meter_provider(options, resource) + if PSUTIL_AVAILABLE: + create_meter_provider(options, resource) + else: + _logger.warning("Metrics collection skipped - psutil not available") if options.collect_logs: handler = create_logger_handler(options, resource) logging.getLogger().addHandler(handler) diff --git a/middleware/exporter_config.py b/middleware/exporter_config.py new file mode 100644 index 0000000..9dbe00c --- /dev/null +++ b/middleware/exporter_config.py @@ -0,0 +1,118 @@ +""" +Exporter configuration that adapts based on the package variant. +Automatically selects HTTP or gRPC exporters based on installed package. + +- middleware-io: gRPC exporters (standard) +- middleware-io-k8s: HTTP exporters (for Kubernetes) +""" + +import logging +from middleware.version import __package_name__, __version__ + +_logger = logging.getLogger(__name__) + +# PACKAGE VARIANT DETECTION + +IS_K8S_VARIANT = "k8s" in __package_name__.lower() + +_logger.info(f"Detected package: {__package_name__}") + +# IMPORT APPROPRIATE EXPORTERS + +if IS_K8S_VARIANT: + # K8s variant - MUST use HTTP exporters + try: + from opentelemetry.exporter.otlp.proto.http.metric_exporter import ( + OTLPMetricExporter as MetricExporter, + ) + from opentelemetry.exporter.otlp.proto.http.trace_exporter import ( + OTLPSpanExporter as TraceExporter, + ) + from opentelemetry.exporter.otlp.proto.http._log_exporter import ( + OTLPLogExporter as LogExporter, + ) + + _logger.info("✓ Using HTTP exporters for K8s variant") + except ImportError as e: + _logger.error(f"Failed to import HTTP exporters for K8s variant: {e}") + raise ImportError( + f"middleware-io-k8s package requires HTTP exporter dependencies. " + f"Please ensure 'opentelemetry-exporter-otlp-proto-http' is installed. " + f"Original error: {e}" + ) from e +else: + # Standard variant - MUST use gRPC exporters + try: + import grpc + from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import ( + OTLPMetricExporter as MetricExporter, + ) + from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import ( + OTLPSpanExporter as TraceExporter, + ) + from opentelemetry.exporter.otlp.proto.grpc._log_exporter import ( + OTLPLogExporter as LogExporter, + ) + + _logger.info("✓ Using gRPC exporters for standard variant") + except ImportError as e: + _logger.error(f"Failed to import gRPC exporters for standard variant: {e}") + raise ImportError( + f"middleware-io package requires gRPC exporter dependencies. " + f"Please ensure 'opentelemetry-exporter-otlp-proto-grpc' is installed. " + f"Original error: {e}" + ) from e + + +def create_metric_exporter(endpoint: str): + """ + Create OTLP metric exporter of appropriate type. + + Args: + endpoint (str): The OTLP endpoint URL + + Returns: + OTLPMetricExporter: HTTP or gRPC based on package variant + """ + if IS_K8S_VARIANT: + # K8s: HTTP exporter + return MetricExporter(endpoint=endpoint + "/v1/metrics") + else: + # Standard: gRPC exporter with compression + return MetricExporter(endpoint=endpoint, compression=grpc.Compression.Gzip) + + +def create_trace_exporter(endpoint: str): + """ + Create OTLP trace exporter of appropriate type. + + Args: + endpoint (str): The OTLP endpoint URL + + Returns: + OTLPSpanExporter: HTTP or gRPC based on package variant + """ + if IS_K8S_VARIANT: + # K8s: HTTP exporter + return TraceExporter(endpoint=endpoint + "/v1/traces") + else: + # Standard: gRPC exporter with compression + return TraceExporter(endpoint=endpoint, compression=grpc.Compression.Gzip) + + +def create_log_exporter(endpoint: str): + """ + Create OTLP log exporter of appropriate type. + + Args: + endpoint (str): The OTLP endpoint URL + + Returns: + OTLPLogExporter: HTTP or gRPC based on package variant + """ + if IS_K8S_VARIANT: + # K8s: HTTP exporter + return LogExporter(endpoint=endpoint + "/v1/logs") + else: + # Standard: gRPC exporter with compression + return LogExporter(endpoint=endpoint, compression=grpc.Compression.Gzip) diff --git a/middleware/log.py b/middleware/log.py index f0d68e3..7d1c9c4 100644 --- a/middleware/log.py +++ b/middleware/log.py @@ -1,10 +1,9 @@ -import grpc +# import grpc import sys import logging from opentelemetry.sdk.resources import Resource -from opentelemetry.exporter.otlp.proto.grpc._log_exporter import ( - OTLPLogExporter, -) +from middleware.exporter_config import create_log_exporter + from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler from opentelemetry.sdk._logs.export import ( BatchLogRecordProcessor, @@ -29,10 +28,8 @@ def create_logger_handler(options: MWOptions, resource: Resource) -> LoggingHand Returns: LoggerProvider: the new logger provider """ - exporter = OTLPLogExporter( - endpoint=options.target, - compression=grpc.Compression.Gzip, - ) + exporter = create_log_exporter(options.target) + logger_provider = LoggerProvider(resource=resource, shutdown_on_exit=True) logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter)) if options.console_exporter: @@ -60,6 +57,7 @@ def create_logger_handler(options: MWOptions, resource: Resource) -> LoggingHand return handler + class MWLoggingHandler(LoggingHandler): @staticmethod def _get_attributes(record: LogRecord): @@ -69,7 +67,7 @@ def _get_attributes(record: LogRecord): if key == "request": if hasattr(value, "method") and hasattr(value, "path"): if len(vars(value)) == 2: - attributes[key] = f'{value.method} {value.path}' + attributes[key] = f"{value.method} {value.path}" else: attributes[key] = str(value) else: @@ -77,4 +75,4 @@ def _get_attributes(record: LogRecord): elif not isinstance(value, (bool, str, bytes, int, float)): attributes[key] = str(value) - return attributes \ No newline at end of file + return attributes diff --git a/middleware/metrics.py b/middleware/metrics.py index e5cfe11..483dd40 100644 --- a/middleware/metrics.py +++ b/middleware/metrics.py @@ -4,20 +4,21 @@ import gc import functools from typing import Generator -import grpc +# import grpc import sys import logging from sys import getswitchinterval from typing import NamedTuple from opentelemetry.metrics import CallbackOptions, Observation, set_meter_provider -import grpc +# import grpc from opentelemetry.sdk.resources import Resource from opentelemetry.sdk.metrics import MeterProvider, Meter from opentelemetry.sdk.metrics.export import ( PeriodicExportingMetricReader, ConsoleMetricExporter, ) -from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter +from middleware.exporter_config import create_metric_exporter + from middleware.options import MWOptions _logger = logging.getLogger(__name__) @@ -34,11 +35,8 @@ def create_meter_provider(options: MWOptions, resource: Resource): Returns: MeterProvider: the new meter provider """ - - exporter = OTLPMetricExporter( - endpoint=options.target, - compression=grpc.Compression.Gzip, - ) + exporter = create_metric_exporter(options.target) + readers = [PeriodicExportingMetricReader(exporter)] if options.console_exporter: output = sys.stdout diff --git a/middleware/options.py b/middleware/options.py index 6ae25e4..ed30f09 100644 --- a/middleware/options.py +++ b/middleware/options.py @@ -9,6 +9,7 @@ from middleware.detectors.detector import Detector, process_detector_input from typing import Union, List from middleware.version import __version__ + # Environment Variable Names OTEL_SERVICE_VERSION = "OTEL_SERVICE_VERSION" DEBUG = "DEBUG" @@ -267,9 +268,19 @@ def __init__( ) if "https" not in self.target: - self.mw_agent_service = os.environ.get(MW_AGENT_SERVICE, mw_agent_service) - if self.mw_agent_service is not None: - self.target = f"http://{self.mw_agent_service}:{DEFAULT_PORT}" + # Special case: Kubernetes Python auto-instrumentation + if os.environ.get("MW_K8S_PYTHON_INSTRUMENTATION") == "true": + # Only set the service name, don't modify self.target + self.mw_agent_service = os.environ.get( + MW_AGENT_SERVICE, mw_agent_service + ) + else: + # Default behavior + self.mw_agent_service = os.environ.get( + MW_AGENT_SERVICE, mw_agent_service + ) + if self.mw_agent_service is not None: + self.target = f"http://{self.mw_agent_service}:{DEFAULT_PORT}" self.custom_resource_attributes = os.environ.get( MW_CUSTOM_RESOURCE_ATTRIBUTES, custom_resource_attributes @@ -278,7 +289,7 @@ def __init__( self.otel_propagators = os.environ.get( OTEL_PROPAGATORS, os.environ.get(MW_PROPAGATORS, otel_propagators) ) - os.environ["OTEL_PROPAGATORS"] = self.otel_propagators + os.environ["OTEL_PROPAGATORS"] = self.otel_propagators self.console_exporter = parse_bool(MW_CONSOLE_EXPORTER, console_exporter) self.debug_log_file = parse_bool(MW_DEBUG_LOG_FILE, debug_log_file) self.project_name = os.environ.get(MW_PROJECT_NAME, project_name) @@ -287,6 +298,7 @@ def __init__( _health_check(options=self) _get_instrument_info(options=self) + def parse_bool( environment_variable: str, default_value: bool, error_message: str = None ) -> bool: @@ -345,8 +357,9 @@ def parse_int( else: return default_value + def _health_check(options: MWOptions): - if options.target == "" or ("https" not in options.target) : + if options.target == "" or ("https" not in options.target): try: response = requests.get( f"http://{options.mw_agent_service}:13133/healthcheck", timeout=5 @@ -356,7 +369,10 @@ def _health_check(options: MWOptions): "MW Agent Health Check is failing ...\nThis could be due to incorrect value of MW_AGENT_SERVICE\nIgnore the warning if you are using MW Agent older than 1.7.7 (You can confirm by running `mw-agent version`)" ) except requests.exceptions.RequestException as e: - _logger.warning(f"MW Agent Health Check is failing ...\nException while MW Agent Health Check:{e}") + _logger.warning( + f"MW Agent Health Check is failing ...\nException while MW Agent Health Check:{e}" + ) + def _get_instrument_info(options: MWOptions): _logger.debug( diff --git a/middleware/trace.py b/middleware/trace.py index bde220e..52e6a94 100644 --- a/middleware/trace.py +++ b/middleware/trace.py @@ -1,4 +1,4 @@ -import grpc +# import grpc import sys import logging from opentelemetry.sdk.resources import Resource @@ -8,7 +8,7 @@ SimpleSpanProcessor, ConsoleSpanExporter, ) -from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter +from middleware.exporter_config import create_trace_exporter from opentelemetry.processor.baggage import ALLOW_ALL_BAGGAGE_KEYS, BaggageSpanProcessor from middleware.options import MWOptions from opentelemetry.trace import set_tracer_provider, Span @@ -16,6 +16,7 @@ _logger = logging.getLogger(__name__) + class ExceptionFilteringSpanProcessor(SpanProcessor): def on_start(self, span: ReadableSpan, parent_context): pass @@ -32,7 +33,10 @@ def on_end(self, span: ReadableSpan): seen_stack_traces = set() filtered_events = [] for event in span.events: - if event.name == "exception" and "exception.stack_details" in event.attributes: + if ( + event.name == "exception" + and "exception.stack_details" in event.attributes + ): stack_trace = event.attributes.get("exception.stack_trace") seen_stack_traces.add(stack_trace) filtered_events.append(event) @@ -50,6 +54,7 @@ def shutdown(self): def force_flush(self, timeout_millis=None): pass + def create_tracer_provider(options: MWOptions, resource: Resource) -> TracerProvider: """ Configures and returns a new TracerProvider to send traces telemetry. @@ -62,10 +67,8 @@ def create_tracer_provider(options: MWOptions, resource: Resource) -> TracerProv TracerProvider: the new tracer provider """ - exporter = OTLPSpanExporter( - endpoint=options.target, - compression=grpc.Compression.Gzip, - ) + exporter = create_trace_exporter(options.target) + trace_provider = TracerProvider( resource=resource, shutdown_on_exit=True, sampler=configure_sampler(options) ) @@ -93,4 +96,4 @@ def create_tracer_provider(options: MWOptions, resource: Resource) -> TracerProv ) ) set_tracer_provider(tracer_provider=trace_provider) - return trace_provider \ No newline at end of file + return trace_provider diff --git a/middleware/version.py b/middleware/version.py index cef6d71..86f3459 100644 --- a/middleware/version.py +++ b/middleware/version.py @@ -1,3 +1,17 @@ -import pkg_resources -__version__ = pkg_resources.get_distribution("middleware-io").version +"""Version and package information.""" + +try: + import pkg_resources + __version__ = pkg_resources.get_distribution("middleware-io").version + __package_name__ = "middleware-io" + +except: + try: + import pkg_resources + __version__ = pkg_resources.get_distribution("middleware-io-k8s").version + __package_name__ = "middleware-io-k8s" + + except: + __version__ = "unknown" + __package_name__ = "middleware-io" \ No newline at end of file diff --git a/pyproject-k8s.toml b/pyproject-k8s.toml new file mode 100644 index 0000000..db71eae --- /dev/null +++ b/pyproject-k8s.toml @@ -0,0 +1,165 @@ +[build-system] +requires = ["setuptools>=42", "wheel"] +build-backend = "setuptools.build_meta" + +[project] +name = "middleware-io-k8s" +version = "2.4.1" +requires-python = ">=3.8" +description = "Middleware's APM tool enables Python developers to effortlessly monitor their applications, gathering distributed tracing, metrics, logs, and profiling data for valuable insights and performance optimization." +authors = [{ name = "middleware-dev" }] +maintainers = [{ name = "middleware-dev" }] +readme = "README.md" +license = { text = "Apache-2.0" } +keywords = [ + "APM", + "middleware", + "monitoring", + "tracing", + "metrics", + "logs", +] +dependencies =[ + "distro==1.9.0", + "opentelemetry-api==1.36.0", + "opentelemetry-exporter-otlp-proto-http==1.36.0", + "opentelemetry-instrumentation==0.57b0", + "opentelemetry-proto==1.36.0", + "opentelemetry-sdk==1.36.0", + "opentelemetry-semantic-conventions==0.57b0", + "opentelemetry-util-http==0.57b0", + "requests==2.32.3", + "psutil==6.0.0", + "opentelemetry-processor-baggage==0.57b0", + "opentelemetry-propagator-b3==1.36.0", + "opentelemetry-propagator-jaeger==1.36.0", + "opentelemetry-propagator-aws-xray==1.0.2", + "opentelemetry-propagator-ot-trace==0.57b0", + "opentelemetry-propagator-gcp==1.9.0", + "opentelemetry-sdk-extension-aws==2.0.2", + "opentelemetry-resource-detector-azure==0.1.5", + "opentelemetry-resourcedetector-gcp==1.9.0a0", + "opentelemetry-resourcedetector-docker==0.4.0", + "gitpython>=3.1.0", + "opentelemetry-instrumentation-aio-pika==0.57b0", + "opentelemetry-instrumentation-aiohttp-client==0.57b0", + "opentelemetry-instrumentation-aiohttp-server==0.57b0", + "opentelemetry-instrumentation-aiokafka==0.57b0", + "opentelemetry-instrumentation-aiopg==0.57b0", + "opentelemetry-instrumentation-asgi==0.57b0", + "opentelemetry-instrumentation-asyncclick==0.57b0", + "opentelemetry-instrumentation-asyncio==0.57b0", + "opentelemetry-instrumentation-asyncpg==0.57b0", + "opentelemetry-instrumentation-aws-lambda==0.57b0", + "opentelemetry-instrumentation-boto==0.57b0", + "opentelemetry-instrumentation-boto3sqs==0.57b0", + "opentelemetry-instrumentation-botocore==0.57b0", + "opentelemetry-instrumentation-cassandra==0.57b0", + "opentelemetry-instrumentation-celery==0.57b0", + "opentelemetry-instrumentation-click==0.57b0", + "opentelemetry-instrumentation-confluent-kafka==0.57b0", + "opentelemetry-instrumentation-dbapi==0.57b0", + "opentelemetry-instrumentation-django==0.57b0", + "opentelemetry-instrumentation-elasticsearch==0.57b0", + "opentelemetry-instrumentation-falcon==0.57b0", + "opentelemetry-instrumentation-fastapi==0.57b0", + "opentelemetry-instrumentation-flask==0.57b0", + "opentelemetry-instrumentation-grpc==0.57b0", + "opentelemetry-instrumentation-httpx==0.57b0", + "opentelemetry-instrumentation-jinja2==0.57b0", + "opentelemetry-instrumentation-kafka-python==0.57b0", + "opentelemetry-instrumentation-logging==0.57b0", + "opentelemetry-instrumentation-mysql==0.57b0", + "opentelemetry-instrumentation-mysqlclient==0.57b0", + "opentelemetry-instrumentation-pika==0.57b0", + "opentelemetry-instrumentation-psycopg==0.57b0", + "opentelemetry-instrumentation-psycopg2==0.57b0", + "opentelemetry-instrumentation-pymemcache==0.57b0", + "opentelemetry-instrumentation-pymongo==0.57b0", + "opentelemetry-instrumentation-pymysql==0.57b0", + "opentelemetry-instrumentation-pymssql==0.57b0", + "opentelemetry-instrumentation-pyramid==0.57b0", + "opentelemetry-instrumentation-redis==0.57b0", + "opentelemetry-instrumentation-remoulade==0.57b0", + "opentelemetry-instrumentation-requests==0.57b0", + "opentelemetry-instrumentation-sqlalchemy==0.57b0", + "opentelemetry-instrumentation-sqlite3==0.57b0", + "opentelemetry-instrumentation-starlette==0.57b0", + "opentelemetry-instrumentation-system-metrics==0.57b0", + "opentelemetry-instrumentation-threading==0.57b0", + "opentelemetry-instrumentation-tornado==0.57b0", + "opentelemetry-instrumentation-tortoiseorm==0.57b0", + "opentelemetry-instrumentation-urllib==0.57b0", + "opentelemetry-instrumentation-urllib3==0.57b0", + "opentelemetry-instrumentation-wsgi", +] + +[project.optional-dependencies] +profiling = ["pyroscope-io==0.8.5; sys_platform != 'win32'"] + +[project.urls] +Source = "https://github.com/middleware-labs/agent-apm-python.git" +Homepage = "https://docs.middleware.io/docs/apm-configuration/python" + +[project.entry-points."opentelemetry_distro"] +middleware_distro = "middleware.distro:MiddlewareDistro" + +[project.scripts] +middleware-run = "opentelemetry.instrumentation.auto_instrumentation:run" +middleware-bootstrap = "opentelemetry.instrumentation.bootstrap:run" + +[project.entry-points."middleware_instrumentor"] +aio-pika = "opentelemetry.instrumentation.aio_pika:AioPikaInstrumentor" +aiohttp-client = "opentelemetry.instrumentation.aiohttp_client:AioHttpClientInstrumentor" +aiohttp-server = "opentelemetry.instrumentation.aiohttp_server:AioHttpServerInstrumentor" +aiokafka = "opentelemetry.instrumentation.aiokafka:AioKafkaInstrumentor" +aiopg = "opentelemetry.instrumentation.aiopg:AiopgInstrumentor" +asyncclick = "opentelemetry.instrumentation.asyncclick:AsyncclickInstrumentor" +asyncio = "opentelemetry.instrumentation.asyncio:AsyncioInstrumentor" +asyncpg = "opentelemetry.instrumentation.asyncpg:AsyncPGInstrumentor" +aws-lambda = "opentelemetry.instrumentation.aws_lambda:AwsLambdaInstrumentor" +boto = "opentelemetry.instrumentation.boto:BotoInstrumentor" +boto3sqs = "opentelemetry.instrumentation.boto3sqs:Boto3SQSInstrumentor" +botocore = "opentelemetry.instrumentation.botocore:BotocoreInstrumentor" +cassandra = "opentelemetry.instrumentation.cassandra:CassandraInstrumentor" +celery = "opentelemetry.instrumentation.celery:CeleryInstrumentor" +click = "opentelemetry.instrumentation.click:ClickInstrumentor" +confluent-kafka = "opentelemetry.instrumentation.confluent_kafka:ConfluentKafkaInstrumentor" +django = "opentelemetry.instrumentation.django:DjangoInstrumentor" +elasticsearch = "opentelemetry.instrumentation.elasticsearch:ElasticsearchInstrumentor" +falcon = "opentelemetry.instrumentation.falcon:FalconInstrumentor" +fastapi = "opentelemetry.instrumentation.fastapi:FastAPIInstrumentor" +flask = "opentelemetry.instrumentation.flask:FlaskInstrumentor" +grpc = "opentelemetry.instrumentation.grpc:GrpcInstrumentorClient" +httpx = "opentelemetry.instrumentation.httpx:HTTPXClientInstrumentor" +jinja2 = "opentelemetry.instrumentation.jinja2:Jinja2Instrumentor" +kafka-python = "opentelemetry.instrumentation.kafka:KafkaInstrumentor" +logging = "opentelemetry.instrumentation.logging:LoggingInstrumentor" +mysql = "opentelemetry.instrumentation.mysql:MySQLInstrumentor" +mysqlclient = "opentelemetry.instrumentation.mysqlclient:MySQLClientInstrumentor" +pika = "opentelemetry.instrumentation.pika:PikaInstrumentor" +psycopg = "opentelemetry.instrumentation.psycopg:PsycopgInstrumentor" +psycopg2 = "opentelemetry.instrumentation.psycopg2:Psycopg2Instrumentor" +pymemcache = "opentelemetry.instrumentation.pymemcache:PymemcacheInstrumentor" +pymongo = "opentelemetry.instrumentation.pymongo:PymongoInstrumentor" +pymssql = "opentelemetry.instrumentation.pymssql:PyMSSQLInstrumentor" +pymysql = "opentelemetry.instrumentation.pymysql:PyMySQLInstrumentor" +pyramid = "opentelemetry.instrumentation.pyramid:PyramidInstrumentor" +redis = "opentelemetry.instrumentation.redis:RedisInstrumentor" +remoulade = "opentelemetry.instrumentation.remoulade:RemouladeInstrumentor" +requests = "opentelemetry.instrumentation.requests:RequestsInstrumentor" +sqlalchemy = "opentelemetry.instrumentation.sqlalchemy:SQLAlchemyInstrumentor" +sqlite3 = "opentelemetry.instrumentation.sqlite3:SQLite3Instrumentor" +starlette = "opentelemetry.instrumentation.starlette:StarletteInstrumentor" +system-metrics = "opentelemetry.instrumentation.system_metrics:SystemMetricsInstrumentor" +threading = "opentelemetry.instrumentation.threading:ThreadingInstrumentor" +tornado = "opentelemetry.instrumentation.tornado:TornadoInstrumentor" +tortoiseorm = "opentelemetry.instrumentation.tortoiseorm:TortoiseORMInstrumentor" +urllib = "opentelemetry.instrumentation.urllib:URLLibInstrumentor" +urllib3 = "opentelemetry.instrumentation.urllib3:URLLib3Instrumentor" + +[tool.pylint.format] +max-line-length = "88" + +[tool.isort] +profile = "black" \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 89fd089..37ccc45 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -41,7 +41,6 @@ dependencies =[ "opentelemetry-resourcedetector-gcp==1.9.0a0", "opentelemetry-resourcedetector-docker==0.4.0", "gitpython>=3.1.0", - "opentelemetry-instrumentation-aio-pika==0.57b0", "opentelemetry-instrumentation-aiohttp-client==0.57b0", "opentelemetry-instrumentation-aiohttp-server==0.57b0",