Merge branch 'master' into feat/snapshot_lib_migration

frontend/src/scenes/experiments/Metrics/PrimaryGoalTrends.tsx

@@ -24,6 +24,10 @@ export function PrimaryGoalTrends(): JSX.Element {
 
     const metricIdx = 0
     const currentMetric = experiment.metrics[metricIdx] as ExperimentTrendsQuery
+    // :FLAG: CLEAN UP AFTER MIGRATION
+    const isDataWarehouseMetric =
+        featureFlags[FEATURE_FLAGS.EXPERIMENTS_HOGQL] &&
+        currentMetric.count_query.series[0].kind === NodeKind.DataWarehouseNode
 
     return (
         <>
@@ -59,10 +63,18 @@ export function PrimaryGoalTrends(): JSX.Element {
                             MathAvailability.All
                         )
 
-                        setTrendsMetric({
-                            metricIdx,
-                            series,
-                        })
+                        if (series[0].kind === NodeKind.DataWarehouseNode) {
+                            setTrendsMetric({
+                                metricIdx,
+                                series,
+                                filterTestAccounts: false,
+                            })
+                        } else {
+                            setTrendsMetric({
+                                metricIdx,
+                                series,
+                            })
+                        }
                     } else {
                         if (actions?.length) {
                             setExperiment({
@@ -101,35 +113,37 @@ export function PrimaryGoalTrends(): JSX.Element {
                 showNumericalPropsOnly={true}
                 {...commonActionFilterProps}
             />
-            <div className="mt-4 space-y-4">
-                <TestAccountFilterSwitch
-                    checked={(() => {
-                        // :FLAG: CLEAN UP AFTER MIGRATION
-                        if (featureFlags[FEATURE_FLAGS.EXPERIMENTS_HOGQL]) {
-                            const val = currentMetric.count_query?.filterTestAccounts
-                            return hasFilters ? !!val : false
-                        }
-                        return hasFilters ? !!experiment.filters.filter_test_accounts : false
-                    })()}
-                    onChange={(checked: boolean) => {
-                        // :FLAG: CLEAN UP AFTER MIGRATION
-                        if (featureFlags[FEATURE_FLAGS.EXPERIMENTS_HOGQL]) {
-                            setTrendsMetric({
-                                metricIdx,
-                                filterTestAccounts: checked,
-                            })
-                        } else {
-                            setExperiment({
-                                filters: {
-                                    ...experiment.filters,
-                                    filter_test_accounts: checked,
-                                },
-                            })
-                        }
-                    }}
-                    fullWidth
-                />
-            </div>
+            {!isDataWarehouseMetric && (
+                <div className="mt-4 space-y-4">
+                    <TestAccountFilterSwitch
+                        checked={(() => {
+                            // :FLAG: CLEAN UP AFTER MIGRATION
+                            if (featureFlags[FEATURE_FLAGS.EXPERIMENTS_HOGQL]) {
+                                const val = currentMetric.count_query?.filterTestAccounts
+                                return hasFilters ? !!val : false
+                            }
+                            return hasFilters ? !!experiment.filters.filter_test_accounts : false
+                        })()}
+                        onChange={(checked: boolean) => {
+                            // :FLAG: CLEAN UP AFTER MIGRATION
+                            if (featureFlags[FEATURE_FLAGS.EXPERIMENTS_HOGQL]) {
+                                setTrendsMetric({
+                                    metricIdx,
+                                    filterTestAccounts: checked,
+                                })
+                            } else {
+                                setExperiment({
+                                    filters: {
+                                        ...experiment.filters,
+                                        filter_test_accounts: checked,
+                                    },
+                                })
+                            }
+                        }}
+                        fullWidth
+                    />
+                </div>
+            )}
             {isExperimentRunning && (
                 <LemonBanner type="info" className="mt-3 mb-3">
                     Preview insights are generated based on {EXPERIMENT_DEFAULT_DURATION} days of data. This can cause a

frontend/src/scenes/feature-flags/FeatureFlagStatusIndicator.tsx

@@ -10,7 +10,12 @@ export function FeatureFlagStatusIndicator({
 }): JSX.Element | null {
     if (
         !flagStatus ||
-        [FeatureFlagStatus.ACTIVE, FeatureFlagStatus.DELETED, FeatureFlagStatus.UNKNOWN].includes(flagStatus.status)
+        [
+            FeatureFlagStatus.ACTIVE,
+            FeatureFlagStatus.INACTIVE,
+            FeatureFlagStatus.DELETED,
+            FeatureFlagStatus.UNKNOWN,
+        ].includes(flagStatus.status)
     ) {
         return null
     }

frontend/src/scenes/persons/PersonScene.tsx

@@ -108,6 +108,7 @@ export function PersonScene(): JSX.Element | null {
         splitMergeModalShown,
         urlId,
         distinctId,
+        primaryDistinctId,
     } = useValues(personsLogic)
     const { loadPersons, editProperty, deleteProperty, navigateToTab, setSplitMergeModalShown, setDistinctId } =
         useActions(personsLogic)
@@ -297,7 +298,7 @@ export function PersonScene(): JSX.Element | null {
                                               </Tooltip>
                                           </div>
                                           <LemonSelect
-                                              value={distinctId || person.distinct_ids[0]}
+                                              value={distinctId || primaryDistinctId}
                                               onChange={(value) => value && setDistinctId(value)}
                                               options={person.distinct_ids.map((distinct_id) => ({
                                                   label: distinct_id,

frontend/src/scenes/persons/personsLogic.tsx

@@ -286,6 +286,24 @@ export const personsLogic = kea<personsLogicType>([
             (featureFlags) => featureFlags[FEATURE_FLAGS.CS_DASHBOARDS],
         ],
         feedEnabled: [(s) => [s.featureFlags], (featureFlags) => !!featureFlags[FEATURE_FLAGS.PERSON_FEED_CANVAS]],
+        primaryDistinctId: [
+            (s) => [s.person],
+            (person): string | null => {
+                // We do not track which distinct ID was created through identify, but we can try to guess
+                const nonUuidDistinctIds = person?.distinct_ids.filter((id) => id?.split('-').length !== 5)
+
+                if (nonUuidDistinctIds && nonUuidDistinctIds?.length >= 1) {
+                    /**
+                     * If there are one or more distinct IDs that are not a UUID, one of them is most likely
+                     * the identified ID. In most cases, there would be only one non-UUID distinct ID.
+                     */
+                    return nonUuidDistinctIds[0]
+                }
+
+                // Otherwise, just fall back to the default first distinct ID
+                return person?.distinct_ids[0] || null
+            },
+        ],
     })),
     listeners(({ actions, values }) => ({
         editProperty: async ({ key, newValue }) => {

frontend/src/scenes/pipeline/hogfunctions/hogFunctionConfigurationLogic.tsx

@@ -451,6 +451,10 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
             errors: (data) => {
                 return {
                     name: !data.name ? 'Name is required' : undefined,
+                    mappings:
+                        data.type === 'site_destination' && (!data.mappings || data.mappings.length === 0)
+                            ? 'You must add at least one mapping'
+                            : undefined,
                     ...(values.inputFormErrors as any),
                 }
             },
@@ -639,8 +643,26 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
             },
         ],
         matchingFilters: [
-            (s) => [s.configuration],
-            (configuration): PropertyGroupFilter => {
+            (s) => [s.configuration, s.useMapping],
+            (configuration, useMapping): PropertyGroupFilter => {
+                // We're using mappings, but none are provided, so match zero events.
+                if (useMapping && !configuration.mappings?.length) {
+                    return {
+                        type: FilterLogicalOperator.And,
+                        values: [
+                            {
+                                type: FilterLogicalOperator.And,
+                                values: [
+                                    {
+                                        type: PropertyFilterType.HogQL,
+                                        key: 'false',
+                                    },
+                                ],
+                            },
+                        ],
+                    }
+                }
+
                 const seriesProperties: PropertyGroupFilterValue = {
                     type: FilterLogicalOperator.Or,
                     values: [],
@@ -809,7 +831,6 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
                 return hogFunction?.template?.hog && hogFunction.template.hog !== configuration.hog
             },
         ],
-
         subTemplate: [
             (s) => [s.template, s.subTemplateId],
             (template, subTemplateId) => {
@@ -821,8 +842,11 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
                 return subTemplate
             },
         ],
-
         forcedSubTemplateId: [() => [router.selectors.searchParams], ({ sub_template }) => !!sub_template],
+        mappingTemplates: [
+            (s) => [s.hogFunction, s.template],
+            (hogFunction, template) => template?.mapping_templates ?? hogFunction?.template?.mapping_templates ?? [],
+        ],
     })),
 
     listeners(({ actions, values, cache }) => ({
@@ -865,6 +889,20 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
                 ...(cache.configFromUrl ?? {}),
             }
 
+            if (values.template?.mapping_templates) {
+                config.mappings = [
+                    ...(config.mappings ?? []),
+                    ...values.template.mapping_templates
+                        .filter((t) => t.include_by_default)
+                        .map((template) => ({
+                            ...template,
+                            inputs: template.inputs_schema?.reduce((acc, input) => {
+                                acc[input.key] = { value: input.default }
+                                return acc
+                            }, {} as Record<string, HogFunctionInputType>),
+                        })),
+                ]
+            }
             const paramsFromUrl = cache.paramsFromUrl ?? {}
             const unsavedConfigurationToApply =
                 (values.unsavedConfiguration?.timestamp ?? 0) > Date.now() - UNSAVED_CONFIGURATION_TTL