openinference.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/graph/types.h>
#include <neograph/observability/tracer.h>
#include <neograph/provider.h>
 
#include <functional>
#include <memory>
#include <string>
#include <string_view>
 
namespace neograph::observability {
 
class NEOGRAPH_API OpenInferenceTracerSession {
public:
    using ChildSpanStarter =
        std::function<std::unique_ptr<Span>(Tracer&, std::string_view)>;
 
    graph::GraphStreamCallback cb;
 
    OpenInferenceTracerSession();
    ~OpenInferenceTracerSession();
 
    // Non-copyable, movable. Move assignment closes the target first.
    OpenInferenceTracerSession(const OpenInferenceTracerSession&) = delete;
    OpenInferenceTracerSession& operator=(const OpenInferenceTracerSession&) = delete;
    OpenInferenceTracerSession(OpenInferenceTracerSession&&) noexcept;
    OpenInferenceTracerSession& operator=(OpenInferenceTracerSession&&) noexcept;
 
    void close();
 
    Span* current_parent() const noexcept;
 
    ChildSpanStarter child_span_starter() const;
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
 
    // NEOGRAPH_API on the friend declaration MUST match the linkage
    // of the free function declared below — without it MSVC reports
    // C2375 ("redefinition; different linkage") because the friend
    // is taken as having default (no-export) linkage while the real
    // declaration is __declspec(dllexport). See
    // feedback_neograph_api_discipline (memory) for the same trap on
    // engine sub-libraries.
    friend NEOGRAPH_API OpenInferenceTracerSession openinference_tracer(
        Tracer&, std::string, std::string);
};
 
NEOGRAPH_API OpenInferenceTracerSession openinference_tracer(
    Tracer& tracer,
    std::string root_name = "graph.run",
    std::string node_span_prefix = "node.");
 
class NEOGRAPH_API OpenInferenceProvider : public Provider {
public:
    OpenInferenceProvider(std::shared_ptr<Provider> inner,
                          Tracer& tracer,
                          std::function<Span*()> parent_lookup = nullptr,
                          std::string span_name = "llm.complete");
 
    OpenInferenceProvider(std::shared_ptr<Provider> inner,
                          Tracer& tracer,
                          const OpenInferenceTracerSession& session,
                          std::string span_name = "llm.complete");
    ~OpenInferenceProvider() override;
 
    PreparedProviderRequest prepare(ProviderRequest request) override;
    std::string_view family() const noexcept override;
    bool host_pumped() const noexcept override;
 
    std::string get_name() const override;
 
protected:
    std::shared_ptr<sp::runtime::Client> endpoint_runtime() const override;
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
} // namespace neograph::observability