RxInfer Usage Telemetry
RxInfer has two separate telemetry features:
- A minimal package usage counter (enabled by default)
- Optional session sharing for better support and development insights
The telemetry implementation in RxInfer has been designed with careful consideration of the community discussion about telemetry in Julia packages, particularly the discourse thread "Pkg.jl telemetry should be opt-in". We've aimed to strike a balance between gathering useful information for package development while respecting user privacy and control.
The following table compares the key properties of RxInfer's two telemetry features.
| Property | Package Usage Counter | Session Sharing |
|---|---|---|
| Entirely Anonymous | Yes | Yes |
| Shared Across Julia Sessions | No | No |
| Enabled by default | Yes (opt-out) | No (opt-in) |
| Deletion Request Support | No (UUIDs not persistent, we cannot backtrace the session to a specific user) | Yes* (only if users save their session ID and share it with us anonymously with the form below, otherwise we cannot backtrace the session to a specific user) |
| Can Be Disabled for a Specific Julia Session | Yes | Yes (disabled by default) |
| Can Be Disabled for All Julia Sessions | Yes | Yes (disabled by default) |
| Can Be Disabled with Environment Variable | Yes | Yes (disabled by default) |
| Customizable Behavior | Yes (with Preferences.jl, see Package Usage Counter manual) | Yes (with Preferences.jl, see Session Sharing manual) |
| Can Be Enabled for a Specific Julia Session | Yes | Yes |
| Can Be Enabled for All Julia Sessions | Yes | Yes |
| What Is Being Recorded | Only timestamp and random UUID | Session metadata, errors, and by default the model source code (constraints/meta); no observed data. See Source Code Sharing |
| Real-Time Sharing of Recorded Data | Yes (on package load) | Optional (manual/automatic) |
| Local Access to Recorded Data | N/A (No data is collected) | Yes (via session inspection, see Session Summary manual) |
| Enables Extra Support from Core Developers | No | Yes* (if users are willing to share their session ID when opening a GitHub issue or a discussion on the GitHub repository, otherwise we cannot backtrace the session to a specific user) |
| Performance Impact | Negligible (only on package load) | Minimal (async sharing) |
| CI Environment Behavior | Automatically disabled | Automatically disabled |
Users are welcome to join our regular online meetings where we analyze the collected data and discuss how it helps shape RxInfer's development.
Package Usage Counter
By default, RxInfer counts how many times the package is loaded via using RxInfer. This counter:
- Only records a timestamp, a random UUID for deduplication, the RxInfer.jl version and the Julia version
- UUIDs are not persistent and are re-generated for each session
- Does not collect any code or data
- Is completely anonymous
- Helps us understand how widely RxInfer is used
Disabling Package Usage Counter
You can disable the counter in several ways:
Using Julia functions:
using RxInfer RxInfer.disable_rxinfer_using_telemetry!() # Requires Julia restartUsing environment variables:
export LOG_USING_RXINFER=false
The counter is also automatically disabled in:
- CI environments (detected via
CI=trueenvironment variable) - When telemetry is disabled via
disable_rxinfer_using_telemetry!() - When the telemetry endpoint is set to
nothing
RxInfer.log_using_rxinfer — Function
log_using_rxinfer()Send an anonymous usage statistics event to the telemetry endpoint on using RxInfer. This function makes an asynchronous HTTP POST request to the configured endpoint. See RxInfer.set_telemetry_endpoint! to configure the endpoint. If the telemetry endpoint is set to nothing, this function does nothing. The call sends a timestamp and a random UUID (re-generated for each usage), the RxInfer.jl version and the Julia version. The request is made asynchronously to avoid blocking the user's workflow. See RxInfer.disable_rxinfer_using_telemetry! to disable telemetry on using RxInfer. Alternatively, set the environment variable LOG_USING_RXINFER to false to disable logging.
RxInfer.disable_rxinfer_using_telemetry! — Function
disable_rxinfer_using_telemetry!()Disable telemetry collection on using RxInfer at compile time. The change requires a Julia session restart to take effect.
See also: set_telemetry_endpoint!, enable_rxinfer_using_telemetry!
RxInfer.enable_rxinfer_using_telemetry! — Function
enable_rxinfer_using_telemetry!()Enable telemetry collection on using RxInfer at compile time. The change requires a Julia session restart to take effect.
See also: set_telemetry_endpoint!, disable_rxinfer_using_telemetry!
RxInfer.set_telemetry_endpoint! — Function
set_telemetry_endpoint!(endpoint)Set the telemetry endpoint URL for RxInfer.jl at compile time. This endpoint is used for collecting anonymous usage statistics to help improve the package.
The change requires a Julia session restart to take effect.
Arguments
endpoint: The URL of the telemetry endpoint as aStringornothing
Session Sharing
RxInfer includes a built-in session tracking feature (detailed in Session Summary) that helps you monitor and debug your inference tasks. You can choose to share these sessions with core developers to:
- Get better support when encountering issues
- Help improve RxInfer through real-world usage insights
- Contribute to community-driven development
Read more about what data is present in the session history in the Session Summary manual.
How to Share Sessions
You can share your session data either manually or automatically.
Manual Sharing
Use the share_session_data function to manually share your session:
RxInfer.share_session_data — Function
share_session_data(session = RxInfer.default_session(); show_progress::Bool = true, share_source_code = nothing)Share your session data to help improve RxInfer.jl and its community. This data helps us:
- Understand how the package is used in practice
- Identify areas for improvement
- Make informed decisions about future development
- Share aggregate usage patterns in our community meetings
The data is organized in a structured way:
- Basic session info (Julia version, OS, etc.)
- Anonymous statistics about different types of package usage
- Information about individual labeled runs
All data is anonymous and only used to improve the package. We discuss aggregate statistics in our public community meetings to make the development process transparent and collaborative.
By default the shared data includes the model source code captured in each run's context (together with the constraints/meta source blocks). If your model source is proprietary, disable this either globally via disable_source_code_sharing! or per call via the share_source_code keyword below. The local session always keeps the full context regardless of this setting.
Arguments
session::Session: The session object containing data to shareshow_progress::Bool = true: Whether to display progress bars during sharingshare_source_code::Union{Bool, Nothing} = nothing: Whether to include the model source code (andconstraints/meta) in the shared payload.nothing(default) follows thepreference_share_source_codecompile-time preference (itselftrueby default);true/falseoverrides it for this call. When source code is not shared, those fields are replaced with a"<redacted>"marker.
Progress Display
When show_progress is true (default), the function displays:
- A blue progress bar for sharing session statistics
- A green progress bar for sharing labeled runs
Automatic Sharing
You can enable automatic session sharing after each session update:
RxInfer.enable_automatic_session_sharing! — Function
enable_automatic_session_sharing!()Enable automatic session sharing after each inference call. The change requires a Julia session restart to take effect. When enabled, session data will be automatically shared after each successful inference call. This helps improve RxInfer by providing usage patterns and helps with debugging issues.
See also: disable_automatic_session_sharing!, share_session_data
RxInfer.disable_automatic_session_sharing! — Function
disable_automatic_session_sharing!()Disable automatic session sharing after inference calls. The change requires a Julia session restart to take effect.
See also: enable_automatic_session_sharing!, share_session_data
When automatic sharing is enabled:
- Session data is shared after each session update
- Sharing is done asynchronously (won't block your code)
- No progress bars or messages are shown
- Failed sharing attempts are silently ignored
Source Code Sharing
When you share a session, the payload for each labeled run includes the context that RxInfer captured for that infer call. By default this includes the model source code (obtained via GraphPPL.getsource), together with the constraints and meta source blocks. This is intentional — the model source is usually the single most useful piece of context when we help you debug an issue you have shared.
If your model source is proprietary or otherwise sensitive, you can prevent it from being transmitted. When source-code sharing is disabled, the model, constraints, and meta fields are replaced with a "<redacted>" marker in the shared payload, while everything else (timing, status, data shape, number of iterations, etc.) is still shared. This only affects what leaves your machine — your local session always keeps the full context for your own inspection (see the Session Summary manual).
You control this in two ways.
Globally, as a compile-time preference (default is to share):
using RxInfer
RxInfer.disable_source_code_sharing!() # do not share source code (requires Julia restart)
RxInfer.enable_source_code_sharing!() # share source code again (default)Or per call, via the share_source_code keyword of share_session_data, which overrides the preference for that call:
# Never share source code for this particular call, regardless of the preference
RxInfer.share_session_data(; share_source_code = false)share_source_code = nothing (the default) follows the compile-time preference.
RxInfer.enable_source_code_sharing! — Function
enable_source_code_sharing!()Enable sharing of the model source code (and the constraints/meta source blocks) when session data is shared, at compile time. This is the default behaviour. The change requires a Julia session restart to take effect.
Source code is only ever transmitted when you opt in to session sharing (manually via share_session_data or automatically via enable_automatic_session_sharing!); this preference controls whether that shared payload includes the source code. You can also override it per call with the share_source_code keyword of share_session_data.
See also: disable_source_code_sharing!, share_session_data
RxInfer.disable_source_code_sharing! — Function
disable_source_code_sharing!()Disable sharing of the model source code (and the constraints/meta source blocks) when session data is shared, at compile time. When disabled, these fields are replaced with a "<redacted>" marker in the shared payload while all other metadata (timing, status, data shape, etc.) is still shared. The local session is unaffected and keeps the full context for your own inspection. The change requires a Julia session restart to take effect.
You can also override this per call with the share_source_code keyword of share_session_data.
See also: enable_source_code_sharing!, share_session_data
RxInfer.preference_share_source_code — Constant
preference_share_source_codeCompile-time preference controlling whether the model source code (and the constraints/meta source blocks) captured in the session invoke context is included when session data is shared. Defaults to true (source code is shared).
This only affects what leaves your machine during session sharing — the local session always keeps the full context for your own inspection. Flip it with enable_source_code_sharing! / disable_source_code_sharing!, or override it per call via the share_source_code keyword of share_session_data.
Using Session IDs in Issues
When you share a session and then open a GitHub issue, include your session ID. This helps us:
- Link your issue to the shared session data
- Understand your usage context
- Provide more accurate and helpful support
Deleting Shared Data
If you wish to delete previously shared session data, you can contact the core developers through GitHub issues at RxInfer.jl or anonymously with the following form.
When requesting deletion, you must provide the session UUID. Without this identifier, we cannot trace specific sessions back to individual users. See the Session Summary manual for details on how to obtain your session ID.
Privacy and Control
Remember:
- Session sharing is completely optional
- All statistics are anonymous, UUIDs are not persistent and are re-generated for each session
- No observed data is shared, only meta information about it (e.g., type of data, number of observations)
- The model source code (and
constraints/meta) is shared by default; you can opt out globally or per call — see Source Code Sharing - You can inspect the sharing code in
src/telemetry.jl - We only use this data to help improve RxInfer and provide better support
We appreciate your help in making RxInfer better! Whether you choose to enable telemetry or share sessions, your contribution helps us improve the package for everyone.
Developers Reference
RxInfer.to_firestore_invoke — Function
to_firestore_invoke(invoke::SessionInvoke, stats_id::UUID; share_source_code::Bool = true)Convert a SessionInvoke object to a Firestore-compatible document format. Includes a reference to the parent session stats.
When share_source_code is false, the source-code fields of the invoke context (:model, :constraints, :meta) are replaced with a "<redacted>" marker before conversion, so they are not included in the shared document. All other context entries (timing, status, data shape, etc.) are preserved. The invoke object itself is left untouched.
RxInfer.to_firestore_value — Function
to_firestore_value(value)Convert a Julia value to a Firestore-compatible value format. Returns a NamedTuple with the appropriate Firestore field type.
RxInfer.to_firestore_session — Function
to_firestore_session(session::Session)Convert a Session object to a Firestore-compatible document format.
RxInfer.to_firestore_document — Function
to_firestore_document(data::NamedTuple)Convert a Julia NamedTuple to a Firestore document format. Returns a NamedTuple with fields in Firestore format.
RxInfer.to_firestore_session_stats — Function
to_firestore_session_stats(stats::SessionStats, session_id::UUID)Convert a SessionStats object to a Firestore-compatible document format. Includes a reference to the parent session.