OpenTelemetry dans les applications Python

La génération efficace de documents et l'observabilité sont des bases essentielles pour développer des systèmes évolutifs et résistants dans le cadre du développement de logiciels contemporains. Les développeurs peuvent instrumenter, collecter et analyser des données observables provenant de systèmes distribués en utilisant OpenTelemetry, une plateforme d'observabilité open-source.

Les développeurs peuvent facilement créer, modifier et produire des documents PDF avec IronPDF, un cadre .NET robuste. Cet article traitera de l'intégration d'OpenTelemetry Python avec IronPDF, en démontrant comment ces deux technologies fonctionnent ensemble pour améliorer l'observabilité et le potentiel de génération de documents.

Les développeurs peuvent accéder à un ensemble étendu de fonctionnalités pour l'instrumentation, la collecte et l'exportation de données télémétriques ouvertes et de données provenant de systèmes distribués avec les packages OpenTelemetry API et SDK, une implémentation du projet OpenTelemetry en Python.

Caractéristiques d'OpenTelemetry

Examinons les fonctionnalités saillantes de l'instrumentation OpenTelemetry pour Python :

Traçage distribué

• Le traçage distribué, qui permet aux développeurs de suivre le parcours des requêtes à travers des systèmes dispersés, est rendu possible par OpenTelemetry pour Python.
• Les traces permettent de connaître la séquence des demandes, y compris les dates et heures des contacts avec les services.
• Les programmes Python peuvent être instrumentés par les développeurs pour enregistrer des portées, qui sont des actions discrètes ou des parties d'une trace distribuée.

Collecte de données

• OpenTelemetry Python facilite l'importation de métriques avec MeterProvider, qui recueille des données numériques concernant le comportement et les performances du système.
• Les développeurs peuvent instrumenter leurs applications pour recueillir des mesures telles que la latence, le débit, les taux d'erreur et l'utilisation des ressources.
• En offrant des informations sur les schémas d'utilisation, les tendances en matière de performances et la santé du système.

Propagation du contexte

• La propagation du contexte est facilitée par le paquet OpenTelemetry API, qui garantit que le contexte distribué, tel que le contexte de trace et d'étendue, est propagé à travers les limites du service.
• Les données télémétriques peuvent être corrélées et contextualisées au fur et à mesure qu'elles se déplacent dans le système grâce à la propagation du contexte, qui préserve la continuité et la cohérence des données.

Bibliothèques d'instrumentation

• OpenTelemetry Python simplifie l'instrumentation des applications Python existantes en fournissant des packages d'instrumentation pour des frameworks, des bibliothèques et des protocoles largement utilisés.
• Des intégrations pour les frameworks web (comme Flask et Django), les clients de base de données (comme SQLAlchemy et Pymongo), les systèmes de messagerie (comme Kafka et RabbitMQ), et plus encore peuvent être trouvées dans les bibliothèques d'instrumentation.

Ecosystème d'exportateurs

• Une gamme d'exportateurs fournis par OpenTelemetry Python permet aux développeurs d'exporter des données de télémétrie vers différents systèmes d'observabilité et backends.
• Les intégrations avec des plateformes d'observabilité telles que Jaeger, Zipkin, Prometheus, AWS X-Ray, Google Cloud Trace et d'autres sont prises en charge par les exportateurs.
• Les exportateurs peuvent être mis en place par les développeurs pour transférer les données télémétriques vers un ou plusieurs backends pour le stockage, l'analyse et l'affichage à long terme.
• Les techniques d'échantillonnage variable sont prises en charge par OpenTelemetry Python pour réguler la quantité de données télémétriques recueillies.
• Les développeurs ont la possibilité d'appliquer une logique d'échantillonnage personnalisée, de régler l'échantillonnage pour échantillonner un certain pourcentage de traces, ou d'échantillonner selon des paramètres prédéfinis (tels que les en-têtes de requête ou les itinéraires).

L'archivage contextuel

• Des outils permettant d'enregistrer des données contextuelles en plus des données télémétriques sont disponibles avec le SDK OpenTelemetry Python.
• Les développeurs peuvent ajouter un contexte de trace et d'étendue aux messages du journal grâce à la journalisation contextuelle, ce qui donne plus de contexte pour le dépannage et le débogage.

Créer et configurer OpenTelemetry Python

Configuration d'OpenTelemetry

Pour configurer OpenTelemetry pour votre projet, vous pouvez commencer par installer les packages nécessaires en utilisant pip install opentelemetry-exporter-jaeger.

pip install opentelemetry-exporter-jaeger

python

Ensuite, installez le SDK OpenTelemetry Python en utilisant la commande suivante pip install opentelemetry-sdk.

pip install opentelemetry-sdk

python

Le package pip opentelemetry-api fournit une API complète pour l'instrumentation, et il offre également une instrumentation automatique facilitant l'instrumentation de vos applications. Une autre manière de le faire pourrait être d'utiliser la méthode d'exportation-importation BatchSpanProcessor pour assurer une exportation efficace des données de télémétrie.

Pour définir les paramètres du SDK OpenTelemetry, créez un fichier de configuration. Le fichier de configuration otel_config.py sert d'exemple. Assurez-vous que toutes vos importations, telles que resources import Resource et trace import TracerProvider, sont présentes pour configurer l'exemple de code sans aucune erreur.

from opentelemetry import trace
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

from opentelemetry.exporter.jaeger.thrift import JaegerExporter

# Configure Jaeger exporter
jaeger_exporter = JaegerExporter(
    agent_host_name="localhost",
    agent_port=6831,
)

# Create a TracerProvider with Jaeger exporter
tracer_provider = TracerProvider(resource=Resource.create({'service.name': 'my-python-service'}))
tracer_provider.add_span_processor(BatchSpanProcessor(jaeger_exporter))
trace.set_tracer_provider(tracer_provider)

python

Dans ce fichier de configuration :

• L'exportateur Jaeger est configuré pour exporter des traces vers un agent Jaeger local.
• En utilisant l'exportateur Jaeger, nous construisons un TracerProvider et le configurons pour qu'il soit le fournisseur de traceur global.
• Pour notre programme Python, nous fournissons le nom du service.

Initialiser OpenTelemetry dans votre application

Importez le module otel_config dans votre programme Python, puis initialisez OpenTelemetry dès le départ avec le code Python d'exemple suivant :

from opentelemetry import trace
from otel_config import tracer_provider

# Initialize OpenTelemetry
trace.get_tracer(__name__)

python

En faisant cela, la configuration trouvée dans otel_config.py est initialisée pour l'instrumentation OpenTelemetry.

Instrumenter votre demande

Utilisez OpenTelemetry pour instrumenter votre programme Python afin qu'il puisse enregistrer des traces. Vous avez deux options pour instrumenter votre code : manuellement ou via les bibliothèques intégrées. Il s'agit d'une illustration de quelques appels d'instrumentation manuelle :

from opentelemetry import trace

# Start a span
with trace.get_tracer(__name__).start_as_current_span("example_span"):
    # Your code here
    pass

python

Afficher les traces dans l'interface utilisateur de Jaeger

Pour voir et examiner les traces enregistrées, rendez-vous dans l'interface utilisateur de Jaeger. Pour afficher les traces enregistrées par le collecteur OpenTelemetry, ouvrez l'interface utilisateur de Jaeger dans votre navigateur web (généralement à l'adresse http://localhost:16686) et choisissez le nom de votre service.

Vous avez réussi à établir et à configurer OpenTelemetry Python dans votre application en suivant ces instructions. Désormais, vous pouvez voir le comportement et les performances de votre programme Python en utilisant OpenTelemetry pour enregistrer des traces et les exporter vers le backend de Jaeger.

Premiers pas avec IronPDF

Qu'est-ce qu'IronPDF ?

Avec la puissante bibliothèque .NET IronPDF d'Iron Software, les développeurs peuvent créer, modifier et présenter des documents PDF dans des applications .NET. Les développeurs peuvent utiliser IronPDF pour créer par programme des documents PDF à partir d'une série de sources, telles que des fichiers PDF préexistants, du texte HTML, des URL et des images. Examinons de plus près les caractéristiques d'IronPDF :

Conversion de HTML en PDF

Les développeurs peuvent facilement convertir du contenu HTML en fichiers PDF avec IronPDF. En utilisant du texte HTML en entrée, les développeurs peuvent produire des documents PDF visuellement riches avec des mises en forme, des images et des styles.

Convertir une URL en PDF

Les développeurs peuvent générer des documents PDF directement à partir d'URL en utilisant IronPDF. Une excellente application de cette fonctionnalité est la capture de contenu à partir de pages web ou de contenu créé dynamiquement à partir d'applications web.

Conversion d'une image en PDF

Avec IronPDF, les images aux formats PNG, JPEG et BMP peuvent être converties en documents PDF. Cette fonction permet aux développeurs d'applications de créer des documents PDF à partir de photos, ce qui est utile pour les applications permettant de créer des albums photos ou d'incorporer des photos dans des fichiers PDF.

Comment installer IronPDF ?

Après avoir vérifié que Python est installé sur votre ordinateur, utilisez pip pour installer IronPDF.

pip install ironpdf

python

Utilisation d'OpenTelemetry pour générer un document PDF avec IronPDF

Ajoutez le code suivant sous l'initialisation d'OpenTelemetry pour utiliser IronPDF afin de créer un document PDF :

from ironpdf import ChromePdfRenderer
from opentelemetry import trace

# Generate PDF document with IronPDF
with trace.get_tracer(__name__).start_as_current_span("pdf_generation"):
    iron_pdf = ChromePdfRenderer()
    html_content = "<html><body><h1>Hello, IronPDF!</h1></body></html>"

    pdf_content = iron_pdf.render_html_as_pdf(html_content)

    # Save or send the PDF content as needed
    with open("output.pdf", "wb") as file:
        file.write(pdf_content)

python

Dans ce passage du code :

• En utilisant le traceur OpenTelemetry, nous commençons une nouvelle portée appelée pdf_generation.
• Nous utilisons IronPDF pour transformer le matériel HTML en document PDF pendant cette période.

• Un fichier appelé output.pdf contient le matériel PDF généré.

  

Conclusion

Enfin, la combinaison de l'observabilité et des capacités de génération de documents dans des applications Python est assurée par la connexion OpenTelemetry Python et IronPDF. Les développeurs peuvent facilement créer des documents de qualité professionnelle à la volée tout en obtenant de meilleures informations sur les performances du système grâce à l'intégration du traçage distribué et de la collecte de métriques avec la génération dynamique de PDF.

La collaboration entre OpenTelemetry Python et IronPDF apparaît comme un puissant catalyseur, permettant aux développeurs de créer des applications fiables, évolutives et performantes, à l'heure où les entreprises recherchent l'efficacité et l'excellence dans leurs solutions logicielles.

Une licence à vie est incluse avec IronPDF, dont le prix est raisonnable lorsqu'il est acheté en bundle. Le bundle est une excellente affaire à seulement $749, et il n'a besoin d'être acheté qu'une seule fois pour plusieurs systèmes. Les titulaires de licence peuvent obtenir une aide technique en ligne 24 heures sur 24 et 7 jours sur 7. Veuillez consulter le site web pour en savoir plus sur la redevance. Visitez cette page pour en savoir plus sur les produits vendus par Iron Software.