Skip to Content
PlatformAnalytics & Metrics

Analytics & Metrics

Analytics and metrics in DarkFeature help you measure the impact of your feature flags and experiments. Track feature adoption, user engagement, and experiment performance to make data-driven decisions.

What Are Analytics & Metrics?

Analytics in DarkFeature provide insights into how your features are performing, which users are engaging with them, and the impact of your experiments. This data helps you optimize features and make informed rollout decisions.

// Basic analytics tracking
df.track('feature-viewed', {
  featureKey: 'new-checkout',
  userId: '123',
  timestamp: Date.now(),
})
 
df.track('feature-converted', {
  featureKey: 'new-checkout',
  userId: '123',
  revenue: 99.99,
  timestamp: Date.now(),
})

Key Metrics

1. Feature Adoption Metrics

Track how many users are using your features.

// Track feature exposure
df.track('feature-exposed', {
  featureKey: 'new-ui',
  userId: user.userId,
  variant: 'variant-a',
  timestamp: Date.now(),
})
 
// Track feature usage
df.track('feature-used', {
  featureKey: 'new-checkout',
  userId: user.userId,
  action: 'checkout-started',
  timestamp: Date.now(),
})

2. Conversion Metrics

Measure how features impact user actions.

// Track conversions
df.track('conversion', {
  featureKey: 'pricing-test',
  userId: user.userId,
  variant: 'discounted',
  conversionType: 'purchase',
  revenue: 99.99,
  timestamp: Date.now(),
})
 
// Track funnel progression
df.track('funnel-step', {
  featureKey: 'onboarding',
  userId: user.userId,
  step: 'profile-completed',
  timestamp: Date.now(),
})

3. Performance Metrics

Monitor feature performance and user experience.

// Track performance metrics
df.track('performance', {
  featureKey: 'new-ui',
  userId: user.userId,
  loadTime: 1200,
  errorRate: 0.01,
  timestamp: Date.now(),
})
 
// Track user satisfaction
df.track('satisfaction', {
  featureKey: 'new-checkout',
  userId: user.userId,
  rating: 5,
  feedback: 'Great experience!',
  timestamp: Date.now(),
})

Experiment Analytics

A/B Test Tracking

// Track experiment exposure
df.track('experiment-exposed', {
  experiment: 'button-color-test',
  variant: 'blue',
  userId: user.userId,
  timestamp: Date.now(),
})
 
// Track experiment conversions
df.track('experiment-conversion', {
  experiment: 'button-color-test',
  variant: 'blue',
  userId: user.userId,
  conversionType: 'click',
  timestamp: Date.now(),
})

Statistical Analysis

// Get experiment results
const results = await df.getExperimentResults('button-color-test')
 
console.log('Experiment Results:', {
  experiment: results.experiment,
  variants: results.variants,
  sampleSize: results.sampleSize,
  confidence: results.confidence,
  winner: results.winner,
  isSignificant: results.isSignificant,
})

Conversion Rate Analysis

// Calculate conversion rates
const conversionRates = {
  control: {
    exposed: 1000,
    converted: 50,
    rate: 0.05,
  },
  'variant-a': {
    exposed: 1000,
    converted: 65,
    rate: 0.065,
  },
}
 
// Calculate lift
const lift =
  (conversionRates['variant-a'].rate - conversionRates.control.rate) /
  conversionRates.control.rate
console.log(`Variant A has ${(lift * 100).toFixed(1)}% lift over control`)

User Journey Tracking

Feature Usage Funnel

// Track user journey through features
const trackUserJourney = (userId, featureKey, step) => {
  df.track('user-journey', {
    userId,
    featureKey,
    step,
    timestamp: Date.now(),
  })
}
 
// Example usage
trackUserJourney('123', 'new-checkout', 'landed')
trackUserJourney('123', 'new-checkout', 'cart-added')
trackUserJourney('123', 'new-checkout', 'payment-started')
trackUserJourney('123', 'new-checkout', 'completed')

Cohort Analysis

// Track user cohorts
df.track('cohort-joined', {
  userId: user.userId,
  cohort: 'january-2024',
  signupDate: '2024-01-15',
  timestamp: Date.now(),
})
 
// Track cohort behavior
df.track('cohort-behavior', {
  userId: user.userId,
  cohort: 'january-2024',
  featureKey: 'new-checkout',
  action: 'first-purchase',
  daysSinceSignup: 7,
  timestamp: Date.now(),
})

Custom Events

Business-Specific Events

// Track business events
df.track('subscription-upgraded', {
  userId: user.userId,
  featureKey: 'premium-features',
  oldPlan: 'free',
  newPlan: 'premium',
  revenue: 29.99,
  timestamp: Date.now(),
})
 
df.track('support-ticket-created', {
  userId: user.userId,
  featureKey: 'new-ui',
  ticketType: 'bug-report',
  severity: 'medium',
  timestamp: Date.now(),
})

User Behavior Events

// Track user behavior
df.track('user-behavior', {
  userId: user.userId,
  featureKey: 'new-checkout',
  action: 'page-scroll',
  scrollDepth: 75,
  timestamp: Date.now(),
})
 
df.track('user-behavior', {
  userId: user.userId,
  featureKey: 'new-checkout',
  action: 'time-spent',
  duration: 300000, // 5 minutes
  timestamp: Date.now(),
})

Real-Time Analytics

Live Dashboard Data

// Get real-time metrics
const getRealTimeMetrics = async featureKey => {
  const metrics = await df.getRealTimeMetrics(featureKey, {
    timeRange: 'last-hour',
    granularity: 'minute',
  })
 
  return {
    featureKey,
    totalExposures: metrics.totalExposures,
    totalConversions: metrics.totalConversions,
    conversionRate: metrics.conversionRate,
    timeSeries: metrics.timeSeries,
  }
}

Alerting

// Set up alerts for important metrics
const setupAlerts = async () => {
  await df.setupAlert({
    featureKey: 'new-checkout',
    metric: 'conversion-rate',
    threshold: 0.05,
    operator: 'less_than',
    duration: '5m',
    action: 'email',
  })
}

Data Export and Integration

Export Analytics Data

// Export analytics data
const exportAnalytics = async (featureKey, dateRange) => {
  const data = await df.exportAnalytics({
    featureKey,
    startDate: dateRange.start,
    endDate: dateRange.end,
    format: 'csv',
  })
 
  return data
}

Third-Party Integration

// Integrate with external analytics
const trackToExternalAnalytics = event => {
  // Send to Google Analytics
  gtag('event', event.action, {
    feature_key: event.featureKey,
    variant: event.variant,
    user_id: event.userId,
  })
 
  // Send to Mixpanel
  mixpanel.track(event.action, {
    featureKey: event.featureKey,
    variant: event.variant,
    userId: event.userId,
  })
}

Advanced Analytics

Multi-Touch Attribution

// Track multiple touchpoints
df.track('touchpoint', {
  userId: user.userId,
  featureKey: 'new-checkout',
  touchpoint: 'email-campaign',
  position: 1,
  timestamp: Date.now(),
})
 
df.track('touchpoint', {
  userId: user.userId,
  featureKey: 'new-checkout',
  touchpoint: 'social-media',
  position: 2,
  timestamp: Date.now(),
})

Predictive Analytics

// Predict user behavior
const predictUserBehavior = async (userId, featureKey) => {
  const prediction = await df.predictBehavior({
    userId,
    featureKey,
    model: 'conversion-prediction',
  })
 
  return {
    userId,
    featureKey,
    conversionProbability: prediction.probability,
    confidence: prediction.confidence,
    factors: prediction.factors,
  }
}

Analytics Best Practices

Event Naming

// ✅ Good event naming
'feature-exposed'
'feature-converted'
'experiment-exposed'
'user-journey-step'
 
// ❌ Avoid
'event1'
'click'
'action'
'data'

Data Consistency

// Consistent user identification
const trackEvent = (eventName, data) => {
  df.track(eventName, {
    ...data,
    userId: user.userId, // Always include userId
    timestamp: Date.now(), // Always include timestamp
    environment: process.env.NODE_ENV, // Include context
  })
}

Privacy Compliance

// GDPR-compliant tracking
const trackWithConsent = (eventName, data) => {
  if (user.hasConsentedToAnalytics) {
    df.track(eventName, {
      ...data,
      userId: user.userId,
      consentGiven: true,
    })
  } else {
    // Track anonymously
    df.track(eventName, {
      ...data,
      anonymousId: generateAnonymousId(),
      consentGiven: false,
    })
  }
}

Analytics Dashboard

Key Performance Indicators

// Calculate KPIs
const calculateKPIs = async featureKey => {
  const metrics = await df.getMetrics(featureKey, {
    timeRange: 'last-30-days',
  })
 
  return {
    featureKey,
    totalUsers: metrics.totalUsers,
    activeUsers: metrics.activeUsers,
    conversionRate: metrics.conversionRate,
    revenue: metrics.totalRevenue,
    averageOrderValue: metrics.averageOrderValue,
  }
}

Trend Analysis

// Analyze trends
const analyzeTrends = async featureKey => {
  const trends = await df.getTrends(featureKey, {
    timeRange: 'last-90-days',
    granularity: 'day',
  })
 
  return {
    featureKey,
    trend: trends.direction, // 'up', 'down', 'stable'
    changePercentage: trends.changePercentage,
    confidence: trends.confidence,
  }
}

Next Steps

Last updated on
EnvironmentsBest Practices