references/adding-feature-flag-code.md · 24000
t # Do something differently for this user # Optional: fetch the payload matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
### Step 2: Include feature flag information when capturing events
If you want use your feature flag to breakdown or filter events in your [insights](/docs/product-analytics/insights.md), you'll need to include feature flag information in those events. This ensures that the feature flag value is attributed correctly to the event.
> **Note:** This step is only required for events captured using our server-side SDKs or [API](/docs/api.md).
There are two methods you can use to include feature flag information in your events:
#### Method 1: Include the `$feature/feature_flag_name` property
In the event properties, include `$feature/feature_flag_name: variant_key`:
Python
PostHog AI
```python
posthog.capture(
"event_name",
distinct_id="distinct_id_of_the_user",
properties={
"$feature/feature-flag-key": "variant-key" # replace feature-flag-key with your flag key. Replace 'variant-key' with the key of your variant
},
)
Method 2: Set send_feature_flags to true
The capture() method has an optional argument send_feature_flags, which is set to false by default. This parameter controls whether feature flag information is sent with the event.
Basic usage
Setting send_feature_flags to True will include feature flag information with the event:
Python
PostHog AI
posthog.capture(
distinct_id="distinct_id_of_the_user",
event='event_name',
send_feature_flags=True
)
Advanced usage (v6.3.0+)
As of version 6.3.0, send_feature_flags can also accept a dictionary for more granular control:
Python
PostHog AI
posthog.capture(
distinct_id="distinct_id_of_the_user",
event='event_name',
send_feature_flags={
'only_evaluate_locally': True,
'person_properties': {'plan': 'premium'},
'group_properties': {'org': {'tier': 'enterprise'}}
}
)
Performance considerations
-
With local evaluation: When local evaluation is configured, setting
send_feature_flags: Truewill not make additional server requests. Instead, it uses the locally cached feature flags, and it provides an interface for including person and/or group properties needed to evaluate the flags in the context of the event, if required. -
Without local evaluation: PostHog will make an additional request to fetch feature flag information before capturing the event, which adds delay.
Breaking change in v6.3.0
Prior to version 6.3.0, feature flags were automatically sent with events when using local evaluation, even when send_feature_flags was not explicitly set. This behavior has been removed in v6.3.0 to be more predictable and explicit.
If you were relying on this automatic behavior, you must now explicitly set send_feature_flags=True to continue sending feature flags with your events.
Fetching all flags for a user
You can fetch all flag values for a single user by calling get_all_flags() or get_all_flags_and_payloads().
This is useful when you need to fetch multiple flag values and don't want to make multiple requests.
Python
PostHog AI
posthog.get_all_flags('distinct_id_of_your_user')
posthog.get_all_flags_and_payloads('distinct_id_of_your_user')
Sending $feature_flag_called events
Capturing $feature_flag_called events enable PostHog to know when a flag was accessed by a user and thus provide analytics and insights on the flag. By default, we send a these event when:
- You call
posthog.get_feature_flag()orposthog.feature_enabled(), AND - It's a new user, or the value of the flag has changed.
Note: Tracking whether it's a new user or if a flag value has changed happens in a local cache. This means that if you reinitialize the PostHog client, the cache resets as well – causing
$feature_flag_calledevents to be sent again when callingget_feature_flagorfeature_enabled. PostHog is built to handle this, and so duplicate$feature_flag_calledevents won't affect your analytics.
You can disable automatically capturing $feature_flag_called events. For example, when you don't need the analytics, or it's being called at such a high volume that sending events slows things down.
To disable it, set the send_feature_flag_events argument in your function call, like so:
Python
PostHog AI
is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user', send_feature_flag_events=False)
# will not send `$feature_flag_called` events
Advanced: Overriding server properties
Sometimes, you may want to evaluate feature flags using person properties, groups, or group properties that haven't been ingested yet, or were set incorrectly earlier.
You can provide properties to evaluate the flag with by using the person properties, groups, and group properties arguments. PostHog will then use these values to evaluate the flag, instead of any properties currently stored on your PostHog server.
For example:
Python
PostHog AI
posthog.get_feature_flag(
'flag-key',
'distinct_id_of_the_user',
person_properties={'property_name': 'value'},
groups={
'your_group_type': 'your_group_id',
'another_group_type': 'your_group_id'},
group_properties={
'your_group_type': {'group_property_name': 'value'},
'another_group_type': {'group_property_name': 'value'}
},
)
Overriding GeoIP properties
By default, a user's GeoIP properties are set using the IP address they use to capture events on the frontend. You may want to override the these properties when evaluating feature flags. A common reason to do this is when you're not using PostHog on your frontend, so the user has no GeoIP properties.
You can override GeoIP properties by including them in the person_properties parameter when evaluating feature flags. This is useful when you're evaluating flags on your backend and want to use the client's location instead of your server's location.
The following GeoIP properties can be overridden:
$geoip_country_code$geoip_country_name$geoip_city_name$geoip_city_confidence$geoip_continent_code$geoip_continent_name$geoip_latitude$geoip_longitude$geoip_postal_code$geoip_subdivision_1_code$geoip_subdivision_1_name$geoip_subdivision_2_code$geoip_subdivision_2_name$geoip_subdivision_3_code$geoip_subdivision_3_name$geoip_time_zone
Simply include any of these properties in the person_properties parameter alongside your other person properties when calling feature flags.
Request timeout
You can configure the feature_flags_request_timeout_seconds parameter when initializing your PostHog client to set a flag request timeout. This helps prevent your code from being blocked in the case when PostHog's servers are too slow to respond. By default, this is set at 3 seconds.
Python
PostHog AI
posthog = Posthog('<ph_project_token>',
host='https://us.i.posthog.com'
feature_flags_request_timeout_seconds=3 // Time in second. Default is 3
)
Error handling
When using the PostHog SDK, it's important to handle potential errors that may occur during feature flag operations. Here's an example of how to wrap PostHog SDK methods in an error handler:
Python
PostHog AI
def handle_feature_flag(client, flag_key, distinct_id):
try:
is_enabled = client.is_feature_enabled(flag_key, distinct_id)
print(f"Feature flag '{flag_key}' for user '{distinct_id}' is {'enabled' if is_enabled else 'disabled'}")
return is_enabled
except Exception as e:
print(f"Error fetching feature flag '{flag_key}': {str(e)}")
raise e
# Usage example
try:
flag_enabled = handle_feature_flag(client, 'new-feature', 'user-123')
if flag_enabled:
# Implement new feature logic
else:
# Implement old feature logic
except Exception as e:
# Handle the error at a higher level
PHP
There are 2 steps to implement feature flags in PHP:
Step 1: Evaluate the feature flag value
Boolean feature flags
PHP
PostHog AI
$isMyFlagEnabledForUser = PostHog::isFeatureEnabled('flag-key', 'distinct_id_of_your_user')
if ($isMyFlagEnabledForUser) {
// Do something differently for this user
}
Multivariate feature flags
PHP
PostHog AI
$enabledVariant = PostHog::getFeatureFlag('flag-key', 'distinct_id_of_your_user')
if ($enabledVariant === 'variant-key') { # replace 'variant-key' with the key of your variant
# Do something differently for this user
}
Step 2: Include feature flag information when capturing events
If you want use your feature flag to breakdown or filter events in your insights, you'll need to include feature flag information in those events. This ensures that the feature flag value is attributed correctly to the event.
Note: This step is only required for events captured using our server-side SDKs or API.
There are two methods you can use to include feature flag information in your events:
Method 1: Include the $feature/feature_flag_name property
In the event properties, include $feature/feature_flag_name: variant_key:
PHP
PostHog AI
PostHog::capture([
'distinctId' => 'distinct_id_of_your_user',
'event' => 'event_name',
'properties' => [
'$feature/feature-flag-key' => 'variant-key' // replace feature-flag-key with your flag key. Replace 'variant-key' with the key of your variant
]
]);
Method 2: Set send_feature_flags to true
The capture() method has an optional argument send_feature_flags, which is set to false by default. By setting this to true, feature flag information will automatically be sent with the event.
Note that by doing this, PostHog will make an additional request to fetch feature flag information before capturing the event. So this method is only recommended if you don't mind the extra API call and delay.
PHP
PostHog AI
PostHog::capture([
'distinctId' => 'distinct_id_of_your_user',
'event' => 'event_name',
'send_feature_flags' => true
]);
Fetching all flags for a user
You can fetch all flag values for a single user by calling getAllFlags().
This is useful when you need to fetch multiple flag values and don't want to make multiple requests.
PHP
PostHog AI
PostHog::getAllFlags('distinct_id_of_your_user')
Sending $feature_flag_called events
Capturing $feature_flag_called events enable PostHog to know when a flag was accessed by a user and thus provide analytics and insights on the flag. By default, we send a these event when:
- You call
getFeatureFlag()orisFeatureEnabled(), AND - It's a new user, or the value of the flag has changed.
Note: Tracking whether it's a new user or if a flag value has changed happens in a local cache. This means that if you reinitialize the PostHog client, the cache resets as well – causing
$feature_flag_calledevents to be sent again when callinggetFeatureFlagorisFeatureEnabled. PostHog is built to handle this, and so duplicate$feature_flag_calledevents won't affect your analytics.
You can disable automatically capturing $feature_flag_called events. For example, when you don't need the analytics, or it's being called at such a high volume that sending events slows things down.
To disable it, set the sendFeatureFlagEvents argument in your function call, like so:
PHP
PostHog AI
$isMyFlagEnabledForUser = PostHog::isFeatureEnabled(
key: 'flag-key',
distinctId: 'distinct_id_of_your_user',
sendFeatureFlagEvents: false
)
Advanced: Overriding server properties
Sometimes, you may want to evaluate feature flags using person properties, groups, or group properties that haven't been ingested yet, or were set incorrectly earlier.
You can provide properties to evaluate the flag with by using the person properties, groups, and group properties arguments. PostHog will then use these values to evaluate the flag, instead of any properties currently stored on your PostHog server.
For example:
PHP
PostHog AI
PostHog::getFeatureFlag(
'flag-key',
'distinct_id_of_the_user',
[
'your_group_type' => 'your_group_id',
'another_group_type' => 'your_group_id'
], // groups
['property_name' => 'value'], // person properties
[
'your_group_type' => ['group_property_name' => 'value'],
'another_group_type' => ['group_property_name' => 'value']
], // group properties
false, // onlyEvaluateLocally, Optional. Defaults to false.
true // sendFeatureFlagEvents
);
Overriding GeoIP properties
By default, a user's GeoIP properties are set using the IP address they use to capture events on the frontend. You may want to override the these properties when evaluating feature flags. A common reason to do this is when you're not using PostHog on your frontend, so the user has no GeoIP properties.
You can override GeoIP properties by including them in the person_properties parameter when evaluating feature flags. This is useful when you're evaluating flags on your backend and want to use the client's location instead of your server's location.
The following GeoIP properties can be overridden:
$geoip_country_code$geoip_country_name$geoip_city_name$geoip_city_confidence$geoip_continent_code$geoip_continent_name$geoip_latitude$geoip_longitude$geoip_postal_code$geoip_subdivision_1_code$geoip_subdivision_1_name$geoip_subdivision_2_code$geoip_subdivision_2_name$geoip_subdivision_3_code$geoip_subdivision_3_name$geoip_time_zone
Simply include any of these properties in the person_properties parameter alongside your other person properties when calling feature flags.
Request timeout
You can configure the feature_flag_request_timeout_ms parameter when initializing your PostHog client to set a flag request timeout. This helps prevent your code from being blocked in the case when PostHog's servers are too slow to respond. By default, this is set at 3 seconds.
PHP
PostHog AI
PostHog::init("<ph_project_token>",
[
'host' => 'https://us.i.posthog.com',
'feature_flag_request_timeout_ms' => 3000 // Time in milliseconds. Default is 3000 (3 seconds).
]
);
Error handling
When using the PostHog SDK, it's important to handle potential errors that may occur during feature flag operations. Here's an example of how to wrap PostHog SDK methods in an error handler:
PHP
PostHog AI
function handleFeatureFlag($client, $flagKey, $distinctId) {
try {
$isEnabled = $client->isFeatureEnabled($flagKey, $distinctId);
echo "Feature flag '$flagKey' for user '$distinctId' is " . ($isEnabled ? 'enabled' : 'disabled') . "\n";
return $isEnabled;
} catch (Exception $e) {
echo "Error fetching feature flag '$flagKey': " . $e->getMessage() . "\n";
// Optionally, you can return a default value or throw the error
// return false; // Default to disabled
throw $e;
}
}
// Usage example
try {
$flagEnabled = handleFeatureFlag($client, 'new-feature', 'user-123');
if ($flagEnabled) {
// Implement new feature logic
} else {
// Implement old feature logic
}
} catch (Exception $e) {
// Handle the error at a higher level
echo 'Feature flag check failed, using default behavior';
// Implement fallback logic
}
Ruby
There are 2 steps to implement feature flags in Ruby:
Step 1: Evaluate the feature flag value
Boolean feature flags
Ruby
PostHog AI
is_my_flag_enabled = posthog.is_feature_enabled('flag-key', 'distinct_id_of_your_user')
if is_my_flag_enabled
# Do something differently for this user
# Optional: fetch the payload
matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
end
Multivariate feature flags
Ruby
PostHog AI
enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')
if enabled_variant == 'variant-key' # replace 'variant-key' with the key of your variant
# Do something differently for this user
# Optional: fetch the payload
matched_flag_payload = posthog.get_feature_flag_payload('variant-key', 'distinct_id_of_your_user')
end
Step 2: Include feature flag information when capturing events
If you want use your feature flag to breakdown or filter events in your insights, you'll need to include feature flag information in those events. This ensures that the feature flag value is attributed correctly to the event.
Note: This step is only required for events captured using our server-side SDKs or API.
There are two methods you can use to include feature flag information in your events:
Method 1: Include the $feature/feature_flag_name property
In the event properties, include $feature/feature_flag_name: variant_key:
Ruby
PostHog AI
posthog.capture({
distinct_id: 'distinct_id_of_your_user',
event: 'event_name',
properties: {
'$feature/feature-flag-key': 'variant-key', # replace feature-flag-key with your flag key. Replace 'variant-key' with the key of your variant
}
})
Method 2: Set send_feature_flags to true
The capture() method has an optional argument send_feature_flags, which is set to false by default. This parameter controls whether feature flag information is sent with the event.
Basic usage
Setting send_feature_flags to true will include feature flag information with the event:
Ruby
PostHog AI
posthog.capture({
distinct_id: 'distinct_id_of_your_user',
event: 'event_name',
send_feature_flags: true,
})
Advanced usage (v3.1.0+)
As of version 3.1.0, send_feature_flags can also accept a hash for more granular control:
Ruby
PostHog AI
posthog.capture({
distinct_id: 'distinct_id_of_your_user',
event: 'event_name',
send_feature_flags: {
only_evaluate_locally: true,
person_properties: { plan: 'premium' },
group_properties: { org: { tier: 'enterprise' } }
}
})
Performance considerations
-
With local evaluation: When local evaluation is configured, setting
send_feature_flags: truewill not make additional server requests. Instead, it uses the locally cached feature flags, and it provides an interface for including person and/or group properties needed to evaluate the flags in the context of the event, if required. -
Without local evaluation: PostHog will make an additional request to fetch feature flag information before capturing the event, which adds delay.
Breaking change in v3.1.0
Prior to version 3.1.0, feature flags were automatically sent with events when using local evaluation, even when send_feature_flags was not explicitly set. This behavior has been removed in v3.1.0 to be more predictable and explicit.
If you were relying on this automatic behavior, you must now explicitly set send_feature_flags: true to continue sending feature flags with your events.
Fetching all flags for a user
You can fetch all flag values for a single user by calling get_all_flags() or get_all_flags_and_payloads().
This is useful when you need to fetch multiple flag values and don't want to make multiple requests.
Ruby
PostHog AI
posthog.get_all_flags('distinct_id_of_your_user')
posthog.get_all_flags_and_payloads('distinct_id_of_your_user')
Sending $feature_flag_called events
Capturing $feature_flag_called events enable PostHog to know when a flag was accessed by a user and thus provide analytics and insights on the flag. By default, we send a these event when:
- You call
posthog.get_feature_flag()orposthog.is_feature_enabled(), AND - It's a new user, or the value of the flag has changed.
Note: Tracking whether it's a new user or if a flag value has changed happens in a local cache. This means that if you reinitialize the PostHog client, the cache resets as well – causing
$feature_flag_calledevents to be sent again when callingget_feature_flagoris_feature_enabled. PostHog is built to handle this, and so duplicate$feature_flag_calledevents won't affect your analytics.
You can disable automatically capturing $feature_flag_called events. For example, when you don't need the analytics, or it's being called at such a high volume that sending events slows things down.
To disable it, set the send_feature_flag_events argument in your function call, like so:
Ruby
PostHog AI
is_my_flag_enabled = posthog.is_feature_enabled(
'flag-key',
'distinct_id_of_your_user',
send_feature_flag_events: true)
Advanced: Overriding server properties
Sometimes, you may want to evaluate feature flags using person properties, groups, or group properties that haven't been ingested yet, or were set incorrectly earlier.
You can provide properties to evaluate the flag with by using the person properties, groups, and group properties arguments. PostHog will then use these values to evaluate the flag, instead of any properties currently stored on your PostHog server.
For example:
Ruby
PostHog AI
posthog.get_feature_flag(
'flag-key',
'distinct_id_of_the_user',
person_properties: {
'property_name': 'value'
},
groups: {
'your_group_type': 'your_group_id',
'another_group_type': 'your_group_id',
},
group_properties: {
'your_group_type': {
'group_property_name': 'value'
}
'another_group_type': {
'group_property_name': 'value'
}
},
)
Overriding GeoIP properties
By default, a user's GeoIP properties are set using the IP address they use to capture events on the frontend. You may want to override the these properties when evaluating feature flags. A common reason to do this is when you're not using PostHog on your frontend, so the user has no GeoIP properties.
You can override GeoIP properties by including them in the person_properties parameter when evaluating feature flags. This is useful when you're evaluating flags on your backend and want to use the client's location instead of your server's location.
The following GeoIP properties can be overridden:
$geoip_country_code$geoip_country_name$geoip_city_name$geoip_city_confidence$geoip_continent_code$geoip_continent_name$geoip_latitude$geoip_longitude$geoip_postal_code$geoip_subdivision_1_code$geoip_subdivision_1_name$geoip_subdivision_2_code$geoip_subdivision_2_name$geoip_subdivision_3_code$geoip_subdivision_3_name$geoip_time_zone
Simply include any of these properties in the person_properties parameter alongside your other person properties when calling feature flags.
Request timeout
You can configu