posthog-rs 0.10.0

The official Rust client for Posthog (https://posthog.com/).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Official Rust SDK for PostHog.
//!
//! Use [`client`] to construct a [`Client`], [`Event`] to capture analytics
//! events, and [`Client::evaluate_flags`] with [`EvaluateFlagsOptions`] for
//! feature flag evaluation.
//!
//! See the [PostHog Rust SDK documentation](https://posthog.com/docs/libraries/rust)
//! for installation, configuration, and more examples.
//!
//! # Getting started
//!
//! Add `posthog-rs` to your `Cargo.toml`, then initialize a client with your
//! project API key.
//!
//! ```no_run
//! use posthog_rs::{client, EvaluateFlagsOptions, Event};
//!
//! #[cfg(feature = "async-client")]
//! #[tokio::main]
//! async fn main() -> Result<(), posthog_rs::Error> {
//!     let api_key = std::env::var("POSTHOG_API_KEY")
//!         .expect("set POSTHOG_API_KEY to your PostHog project API key");
//!
//!     let posthog = client(api_key.as_str()).await;
//!     let distinct_id = "user-123";
//!
//!     // Capture an analytics event.
//!     let mut event = Event::new("signed_up", distinct_id);
//!     event.insert_prop("plan", "pro")?;
//!     posthog.capture(event).await?;
//!
//!     // Evaluate feature flags once, then read from the snapshot.
//!     let flags = posthog
//!         .evaluate_flags(distinct_id, EvaluateFlagsOptions::default())
//!         .await?;
//!
//!     if flags.is_enabled("new-onboarding") {
//!         let mut event = Event::new("onboarding_step_completed", distinct_id);
//!         event.with_flags(&flags.only_accessed());
//!         posthog.capture(event).await?;
//!     }
//!
//!     Ok(())
//! }
//!
//! #[cfg(not(feature = "async-client"))]
//! fn main() -> Result<(), posthog_rs::Error> {
//!     let api_key = std::env::var("POSTHOG_API_KEY")
//!         .expect("set POSTHOG_API_KEY to your PostHog project API key");
//!
//!     let posthog = client(api_key.as_str());
//!     let distinct_id = "user-123";
//!
//!     // Capture an analytics event.
//!     let mut event = Event::new("signed_up", distinct_id);
//!     event.insert_prop("plan", "pro")?;
//!     posthog.capture(event)?;
//!
//!     // Evaluate feature flags once, then read from the snapshot.
//!     let flags = posthog.evaluate_flags(distinct_id, EvaluateFlagsOptions::default())?;
//!
//!     if flags.is_enabled("new-onboarding") {
//!         let mut event = Event::new("onboarding_step_completed", distinct_id);
//!         event.with_flags(&flags.only_accessed());
//!         posthog.capture(event)?;
//!     }
//!
//!     Ok(())
//! }
//! ```
mod client;
mod compression;
mod endpoints;
mod error;
mod event;
#[cfg(feature = "capture-v1")]
mod event_v1;
mod feature_flag_evaluations;
mod feature_flags;
mod global;
mod local_evaluation;

// Public interface - any change to this is breaking!
// Client
pub use client::client;
pub use client::CaptureCompression;
pub use client::Client;
pub use client::ClientOptions;
pub use client::ClientOptionsBuilder;
pub use client::ClientOptionsBuilderError;

// Endpoints
pub use endpoints::{
    Endpoint, EndpointManager, DEFAULT_HOST, EU_INGESTION_ENDPOINT, US_INGESTION_ENDPOINT,
};

// Error
pub use error::Error;

// Event
pub use event::Event;
#[cfg(feature = "capture-v1")]
pub use event::EventOptions;

// V1 Capture types
#[cfg(feature = "capture-v1")]
pub use event_v1::{CaptureResponse, EventResult, EventStatus};

// Feature Flags
pub use feature_flag_evaluations::{EvaluateFlagsOptions, FeatureFlagEvaluations};
pub use feature_flags::{
    match_feature_flag, match_feature_flag_with_context, match_property_with_context,
    CohortDefinition, EvaluationContext, FeatureFlag, FeatureFlagCondition, FeatureFlagFilters,
    FeatureFlagsResponse, FlagDetail, FlagMetadata, FlagReason, FlagValue, InconclusiveMatchError,
    MultivariateFilter, MultivariateVariant, Property,
};

// Local Evaluation
pub use local_evaluation::{
    Cohort, FlagCache, FlagPoller, LocalEvaluationConfig, LocalEvaluationResponse, LocalEvaluator,
};

#[cfg(feature = "async-client")]
pub use local_evaluation::AsyncFlagPoller;

// We expose a global capture function as a convenience, that uses a global client
pub use global::capture;
pub use global::disable as disable_global;
pub use global::init_global_client as init_global;
pub use global::is_disabled as global_is_disabled;