17291208:

12,23 Yuan Chuanghui·Shanghai Station, sprechen wir über die LLM-Infrastruktur

1. Einleitung

KaiwuDB verfügt über eine vollständige Funktion zur Erfassung von Verhaltensdaten. Diese Funktion erfordert, dass das C/E/T-Ende des KaiwuDB-Datenbanksystems über vollständige Funktionen zur Sammlung von Indikatoren in verschiedenen Dimensionen in verschiedenen Prozessen verfügt. Nachdem verschiedene Prozesse die Sammlung von Indikatoren abgeschlossen haben, werden die Indikatoren in Opentelemetry gespeichert Sammler. Prometheus, um Displays zu finden.

Opentelemetry ist ein Tool für die verteilte Ablaufverfolgung und Leistungsüberwachung über mehrere Dienste und Systeme hinweg, mit dem Sie eine Vielzahl von Daten für Ihre Anwendung sammeln, aufzeichnen und analysieren können.

Eine der Komponenten ist Opentelemetry Collector, der einen universellen Datensammler bereitstellt, der Daten aus mehreren Datenquellen sammeln und umwandeln und an mehrere Zielspeicher- oder Analyseplattformen senden kann.

1. Hauptfunktionen von Opentelemetry Collector

Datenerfassung: Opentelemetry Collector kann Daten aus mehreren Datenquellen sammeln, darunter OpenTracing, OpenCensus, Jaeger, Zipkin und Prometheus;
Datenkonvertierung: Opentelemetry Collector kann aus verschiedenen Quellen gesammelte Daten zur einfachen Übertragung, Speicherung und Analyse in ein konsistentes Format konvertieren;
Datenexport: Opentelemetry Collector kann transformierte Daten auf mehrere Zielspeicher- oder Analyseplattformen exportieren, darunter Kafka, AWS S3, Google Cloud Storage, Elasticsearch, Prometheus, Zipkin und mehr.

2. Opentelemetry Collector beziehen

Opentelemetry Collector ist ein Open-Source-Projekt. Sie können den Quellcode und die Release-Version in Githhub https://github.com/open-telemetry/opentelemetry-collector anzeigen und herunterladen


git clone [email protected]:open-telemetry/opentelemetry-collector.git

Sie können das Bild auch über Docker ziehen:


docker pull otel/opentelemetry-collector:0.78.0

2. Überwachung und Nutzung

Opentelemetry Collector überwacht Datenbanken, um Metriken zur Datenbankleistung und zum Datenbankverhalten zu sammeln. Es kann mit der OpenTelemetry-API oder verfügbaren Datenbanktreibern betrieben werden, um die folgenden Metriken zu erfassen:

Antwortzeit: Die Antwortzeit von Datenbankanfragen kann gemessen werden, um die Leistung und Effizienz von Abfragen zu bestimmen;
Fehlerrate: Kann ermitteln, ob in der Datenbank Fehler aufgetreten sind und wie viele Anforderungen während des Anforderungsprozesses fehlgeschlagen sind.
Anzahl der Verbindungen: Die Anzahl der offenen Verbindungen in der Datenbank kann gemessen werden, um zu bestimmen, wie viele Clients eine Verbindung herstellen.
Cache-Effizienz: Sie können erkennen, ob die Datenbank Cache verwendet, und die Cache-Trefferquote bestimmen.
Lese-Schreib-Verhältnis: Sie können verstehen, wie viele Datenbankanforderungen Lesevorgänge und Schreibvorgänge sind.

Durch die Überwachung der Datenbank durch Opentelemetry Collector können Datenbankleistungsprobleme, wie lange Antwortzeiten, hohe Fehlerraten usw., rechtzeitig erkannt, diagnostiziert und optimiert werden. Darüber hinaus kann es auch mit anderen Komponenten verwendet werden. Wenn beispielsweise einige Geschäftsdaten in der Datenbank abgefragt werden müssen, können diese Indikatoren in das gesamte Geschäftsüberwachungssystem integriert werden, um umfassendere Geschäftsleistungsindikatoren zu erhalten.

Der Prozess der Indikatorerfassung in Opentelemetry ist wie folgt:

MetricReader ruft regelmäßig die Collect-Methode von MetricCollector auf. In der Collect-Methode von MetricCollector werden alle Indikatoren im MeterProvider durchlaufen, gepackt und an MetricReader zurückgegeben. Anschließend werden die Indikatoren über das http-Protokoll und die Expor-Methode an OpenTelemetry-Collector gesendet .

Opentelemetry Collector unterstützt das Sammeln von Indikatordaten aus Prometheus-Datenquellen und deren Konvertierung in das OpenTelemetry-Standardformat, um plattform- und sprachübergreifende Anwendungen zu ermöglichen. Hier sind die Schritte zur Verwendung des Opentelemetry Collector zum Sammeln und Verarbeiten von Metrikdaten aus einer Prometheus-Datenquelle:

1. Platzierung des Opentelemetry Collectors

Die Konfiguration von Opentelemetry Collector kann aus folgenden Teilen bestehen:

Empfänger: Empfänger, dh die Form der vom Collector empfangenen Datenquelle;
Prozessor: Ein Plug-in ähnlich der Datenverarbeitung, das zwischen Empfänger und Exportor ausgeführt wird;
Exportor: Exporter, dh die Form der vom Collector ausgegebenen Datenquelle;
Service: Der Abschnitt wird verwendet, um zu konfigurieren, welche Funktionen OpenTelemetry Collector basierend auf der obigen Konfiguration aktiviert.

2. Starten Sie Opentelemetry Collector

Wenn Sie den Opentelemetry Collector starten, können Sie über die Befehlszeile oder eine Konfigurationsdatei die Datenquelle und den Zielspeicher oder die Analyseplattform für die Erfassung und den Export angeben.


# start collector using the configuration file
$ ./otelcol --config collector-config.yaml

Sie können das Image auch mit Docker starten:

ocker run -v $(pwd)/config.yaml:/etc/otelcol-contrib/config.yaml otel/opentelemetry-collector:0.78.0

Generieren von Metrikdaten in der Clientanwendung Um Metrikdaten an den Opentelemetry Collector zu senden, muss die Clientanwendung die entsprechende API und Konfiguration zum Generieren der Metrikdaten verwenden. Im Folgenden finden Sie Beispielcode zum Senden von Indikatordaten mithilfe einer C++-Anwendung:

#include <opentelemetry/sdk/metrics/meter.h>
#include <opentelemetry/exporters/otlp/otlp_http/otlp_http_exporter.h>
#include <opentelemetry/sdk/metrics/controller.h>
#include <opentelemetry/sdk/metrics/processormetrics.h>
#include <iostream>
using namespace opentelemetry::sdk::metrics;
using namespace opentelemetry::exporter::otlphttp;
 int main()
{
  try
  {
    // Create a metric exporter
    OtlpHttpExporterOptions opts;
    opts.url = "http://localhost:4317/v1/metrics";
    auto exporter = std::unique_ptr<OtlpHttpExporter>(new OtlpHttpExporter(opts));
     // Create a processor
    std::unique_ptr<Processor> processor(new Processor());
     // Create a controller
    auto controller = std::make_shared<Controller>(std::move(processor), std::chrono::system_clock::now());
     // Create a meter
    auto meter = controller->provider().GetMeter("example");
     // Define a counter metric
    auto counter = meter->NewIntCounter("example_counter", "counts", "1");
     // Record some data
    for (int i = 0; i < 10; i++)
    {
      counter->Add(i, {{"key", "value"}});
    }
     // Shutdown the controller
    controller->Shutdown().wait();
  }
  catch (const std::exception& e)
  {
    std::cerr << "Exception caught: " << e.what() << std::endl;
    return 1;
  }
   return 0;
}

In diesem Beispiel werden ein Metrikexporter, ein Prozessor und ein Controller mit dem OpenTelemetry C++ SDK erstellt, und eine Zählermetrik wird mit meter erstellt. Anschließend zeichnet es die 10 Zählwerte mithilfe der Add-Methode auf und sendet die Metrikdaten an den OpenTelemetry Collector.

3. Daten analysieren und visualisieren

Über Opentelemetry Collector können wir metrische Daten aus Prometheus-Datenquellen auf mehrere Zielspeicher- oder Analyseplattformen exportieren. Im Folgenden finden Sie eine Beispielkonfiguration für den Export von Metrikdaten nach Prometheus:


receivers:
  prometheus:
    config:
      scrape_configs:
        - job_name: 'my-service'
          scrape_interval: 30s
          static_configs:
            - targets: ['localhost:9080/metrics'] # replace with your collector's target
processors:
  batch:
exporters:
  prometheus:
    namespace: my-service
    endpoint: '0.0.0.0:8080' # replace with your prometheus server's endpoint
service:
  pipelines:
    metrics:
      receivers: [prometheus]
      processors: [batch]
      exporters: [prometheus]

In dieser Konfigurationsdatei definieren wir einen Exporter namens „prometheus“ und legen den Export-Namespace und die Endpunktadresse des Prometheus-Servers fest. Durch den Export metrischer Daten nach Prometheus können wir die Abfragesprache von Prometheus, PromQL, für die Datenanalyse und -visualisierung verwenden.

Bei der Überwachung von KaiwuDB wird die Metrics-API von Opentelemetry verwendet, um Gauge- und Counter-Methoden zu erstellen und diese im MeterProvider von opentelemetry zu registrieren. Verwenden Sie gleichzeitig den otlp-Exporter, um die Metrikdaten an den Remote-OTLP-Kollektor zu senden.


opentelemetry::exporter::otlp::OtlpHttpMetricExporterOptions opts;
int interval, timeout;     
ZString ot_url = GetSysConfig("METRICS_PLUGIN", "url");
ZString interval_s = GetSysConfig("METRICS_PLUGIN", "interval");
ZString timeout_s = GetSysConfig("METRICS_PLUGIN", "timeout");
interval = atoi(interval_s.c_str());
timeout = atoi(timeout_s.c_str());
if (ot_url != "")
{
    opts.url = ot_url;
}
else
{
    opts.url = "http://localhost:4318/v1/metrics";
}
// Create OTLP exporter instance
auto exporter = otlp::OtlpHttpMetricExporterFactory::Create(opts);
// Initialize and set the global MeterProvider
metric_sdk::PeriodicExportingMetricReaderOptions options;
options.export_interval_millis = std::chrono::milliseconds(interval);
options.export_timeout_millis = std::chrono::milliseconds(timeout);

// Initialize the reader
std::unique_ptr<metric_sdk::MetricReader> reader{
    new metric_sdk::PeriodicExportingMetricReader(std::move(exporter), options)};
// Initialize the provider
auto resource_attributes = opentelemetry::sdk::resource::ResourceAttributes{
    {"service.name", "service"}};
auto resource = opentelemetry::sdk::resource::Resource::Create(resource_attributes);
auto provider = std::shared_ptr<metrics_api::MeterProvider>(new metric_sdk::MeterProvider(std::unique_ptr<opentelemetry::v1::sdk::metrics::ViewRegistry>(new opentelemetry::v1::sdk::metrics::ViewRegistry()), resource));
auto p = std::static_pointer_cast<metric_sdk::MeterProvider>(provider);
p->AddMetricReader(std::move(reader));
metrics_api::Provider::SetMeterProvider(provider);

Der obige Code wird in KaiwuDB verwendet, um den OTLP-Exporter von OpenTelemetry zu konfigurieren und zu initialisieren, um Indikatordaten an den angegebenen Backend-Dienst zu senden.

Nach dem Starten des Opentelemetry Collectors können Sie zugehörige Überwachungsdaten über die definierte URL http://localhost:4318/v1/metrics abfragen. Promtheus-Daten werden von KaiwuDB bezogen. Das Erfassungsbeispiel lautet wie folgt:

# HELP sys_connection_max_count 
# TYPE sys_connection_max_count gauge
sys_connection_max_count{clusterId="60a10600-497b-4186-88d0-bacafe0a1857",job="KWDB",nodeName="e1Primary",nodeType="E:ME"} 100
# HELP sys_connection_used_count 
# TYPE sys_connection_used_count gauge
sys_connection_used_count{clusterId="60a10600-497b-4186-88d0-bacafe0a1857",job="KWDB",nodeName="e1Primary",nodeType="E:AE"} 0

3. Die Rolle von Überwachungsindikatoren bei der SQL-Optimierung

In KaiwuDB umfasst die Leistungsüberwachung die folgenden Indikatoren

Nachdem Sie eine Verbindung zu KaiwuDB hergestellt haben , erhalten Sie relevante Überwachungsindikatoren über http://localhost:4318/v1/metrics.

Verwenden Sie zum Abfragen das folgende SQL:

Eine erneute Abfrage der Überwachungsindikatoren zeigt, dass die CPU-Auslastung deutlich gestiegen ist.

Da diese SQL-Anweisung Platzhalter (%) zum Fuzzy-Matching von Zeichenfolgen in der Spalte verwendet, kann diese Abfrage bei großen Datenmengen in der Spalte zu einer erhöhten CPU-Auslastung der Datenbank führen, da die gesamte Spalte nach einem Treffer durchsucht werden muss.

So können wir die SQL optimieren, indem wir einen Index hinzufügen oder einen Präfix-Platzhalter verwenden.


ALTER TABLE operation ADD INDEX idx_result (result);

Nachdem Sie erneut SQL für die Abfrage verwendet haben, können Sie feststellen, dass die benötigte Zeit deutlich reduziert wurde.Gleichzeitig ist auch die CPU-Auslastung in den Überwachungsdaten gesunken.

4. Zusammenfassung

Opentelemetry Collector ist ein sehr leistungsstarkes Tool, mit dem Benutzer verteilte Tracing- und Leistungsüberwachungsdaten einfach sammeln, umwandeln und exportieren können. Mit Opentelemetry Collector können Benutzer die Leistung ihrer Anwendungen und Systeme besser verstehen und eine bessere Datenunterstützung für Geschäftsentscheidungen bereitstellen.

Durch die Verwendung von OpenTelemetry zum Sammeln und Analysieren von SQL-Metriken können Sie ganz einfach überwachen, wie effizient jede SQL-Abfrage ausgeführt wird, und potenzielle Leistungsprobleme identifizieren. Dadurch wird die Abfrageleistung optimiert und die Anwendungsleistung verbessert.

Einführung in KaiwuDB-Überwachungskomponenten und zusätzliche SQL-Optimierung