@atproto/bsky 0.0.216 → 0.0.218

package/src/feature-gates/metrics.ts

@@ -0,0 +1,107 @@
+import { featureGatesLogger } from '../logger'
+
+type Events = {
+  'experiment:viewed': {
+    experimentId: string
+    variationId: string
+  }
+  'feature:viewed': {
+    featureId: string
+    featureResultValue: unknown
+    /** Only available if feature has experiment rules applied */
+    experimentId?: string
+    /** Only available if feature has experiment rules applied */
+    variationId?: string
+  }
+}
+
+type Event<M extends Record<string, any>> = {
+  time: number
+  event: keyof M
+  payload: M[keyof M]
+  metadata: Record<string, any>
+}
+
+export type Config = {
+  trackingEndpoint?: string
+}
+
+export class MetricsClient<M extends Record<string, any> = Events> {
+  maxBatchSize = 100
+
+  private started: boolean = false
+  private queue: Event<M>[] = []
+  private flushInterval: NodeJS.Timeout | null = null
+  constructor(private config: Config) {}
+
+  start() {
+    if (this.started) return
+    this.started = true
+    this.flushInterval = setInterval(() => {
+      this.flush()
+    }, 10_000)
+  }
+
+  stop() {
+    if (this.flushInterval) {
+      clearInterval(this.flushInterval)
+      this.flushInterval = null
+    }
+    this.flush()
+  }
+
+  track<E extends keyof M>(
+    event: E,
+    payload: M[E],
+    metadata: Record<string, any> = {},
+  ) {
+    this.start()
+
+    const e = {
+      source: 'appview',
+      time: Date.now(),
+      event,
+      payload,
+      metadata,
+    }
+    this.queue.push(e)
+
+    if (this.queue.length > this.maxBatchSize) {
+      this.flush()
+    }
+  }
+
+  flush() {
+    if (!this.queue.length) return
+    const events = this.queue.splice(0, this.queue.length)
+    this.sendBatch(events)
+  }
+
+  private async sendBatch(events: Event<M>[]) {
+    if (!this.config.trackingEndpoint) return
+
+    try {
+      const res = await fetch(this.config.trackingEndpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ events }),
+        keepalive: true,
+      })
+
+      if (!res.ok) {
+        const errorText = await res.text().catch(() => 'Unknown error')
+        featureGatesLogger.error(
+          { err: new Error(`${res.status} Failed to fetch - ${errorText}`) },
+          'Failed to send metrics',
+        )
+      } else {
+        // Drain response body to allow connection reuse.
+        await res.text().catch(() => {})
+      }
+    } catch (err) {
+      featureGatesLogger.error({ err }, 'Failed to send metrics')
+    }
+  }
+}

package/src/feature-gates/types.ts

@@ -0,0 +1,52 @@
+import type express from 'express'
+import { FeatureGate } from './gates'
+
+/**
+ * The user context passed to the feature gates client for evaluation and
+ * tracking purposes.
+ */
+export type RawUserContext = {
+  /**
+   * The user's DID
+   */
+  viewer: string | null
+  /**
+   * The express request object, used to extract analytics headers for the user context
+   */
+  req: express.Request
+}
+
+/**
+ * Extracted values from the `RawUserContext`. These values should match the
+ * `attributes` we've configured for GrowthBook in our GB dashboard. We also
+ * send these same values as properties in our analytics events, so we want to
+ * make sure they are consistent.
+ */
+export type ParsedUserContext = {
+  did?: string | null
+  deviceId: string
+  sessionId: string
+}
+
+/**
+ * This loosely matches the metadata we send from the client for analytics
+ * events. We want to make sure we have the same properties in both places so
+ * that we can correlate feature gate evaluations with analytics events.
+ *
+ * @see https://github.com/bluesky-social/social-app/blob/76109a58dc7aafccdfbd07a81cbd9925e065d1c0/src/analytics/metadata.ts
+ */
+export type TrackingMetadata = {
+  base: {
+    deviceId: string
+    sessionId: string
+  }
+  session: {
+    did: string | undefined
+  }
+}
+
+/**
+ * Pre-evaluated feature gates map, the result of
+ * `ctx.FeatureGatesClient.checkGates()`
+ */
+export type CheckedFeatureGatesMap = Map<FeatureGate, boolean>

package/src/feature-gates/utils.ts

@@ -0,0 +1,90 @@
+import crypto from 'node:crypto'
+import { type UserContext as GrowthBookUserContext } from '@growthbook/growthbook'
+import { ParsedUserContext, RawUserContext, TrackingMetadata } from './types'
+
+/**
+ * These need to match what the client sends
+ */
+const ANALYTICS_HEADER_DEVICE_ID = 'X-Bsky-Device-Id'
+const ANALYTICS_HEADER_SESSION_ID = 'X-Bsky-Session-Id'
+
+/**
+ * Parse the `RawUserContext` into a `ParsedUserContext` that is used as
+ * GrowthBook `attributes` as well as the metadata payload for our analytics
+ * events. This ensures that the same user properties are used for both feature
+ * gate targeting and analytics.
+ */
+export function parseRawUserContext(
+  userContext: RawUserContext,
+): ParsedUserContext {
+  const did = userContext.viewer
+
+  // prioritize passthrough header
+  let deviceId = userContext.req.header(ANALYTICS_HEADER_DEVICE_ID)
+  if (!deviceId) {
+    if (did) {
+      /*
+       * If we don't have a device header, fall back to the DID. Our event
+       * proxy ensures ordering based on this deviceId (also called a stableId
+       * in the proxy), so if we have a DID, we want to use it to ensure client
+       * and server events are properly ordered.
+       */
+      deviceId = did
+    } else {
+      /*
+       * Without any better option for identifying the user, we generate a
+       * random deviceId.
+       */
+      deviceId = `anon-${crypto.randomUUID()}`
+    }
+  }
+
+  // prioritize passthrough header
+  let sessionId = userContext.req.header(ANALYTICS_HEADER_SESSION_ID)
+  if (!sessionId) {
+    /*
+     * Without any better option for identifying the user, we generate a
+     * random deviceId.
+     */
+    sessionId = `anon-${crypto.randomUUID()}`
+  }
+
+  return {
+    did,
+    deviceId,
+    sessionId,
+  }
+}
+
+/**
+ * Extract the `ParsedUserContext` from the GrowthBook `UserContext`, which we
+ * passed into `isOn` as `attributes`.
+ */
+export function extractParsedUserContextFromGrowthBookUserContext(
+  userContext: GrowthBookUserContext,
+): ParsedUserContext {
+  return {
+    did: userContext.attributes?.did,
+    deviceId: userContext.attributes?.deviceId,
+    sessionId: userContext.attributes?.sessionId,
+  }
+}
+
+/**
+ * Convert the `ParsedUserContext` into the `TrackingMetadata` format that we
+ * use for our analytics events. This ensures that we have the same user
+ * properties as we do for events from our client app.
+ */
+export function parsedUserContextToTrackingMetadata(
+  parsedUserContext: ParsedUserContext,
+): TrackingMetadata {
+  return {
+    base: {
+      deviceId: parsedUserContext.deviceId,
+      sessionId: parsedUserContext.sessionId,
+    },
+    session: {
+      did: parsedUserContext.did ?? undefined,
+    },
+  }
+}

package/src/hydration/hydrator.ts

@@ -2,7 +2,7 @@ import assert from 'node:assert'
 import { mapDefined } from '@atproto/common'
 import { AtUri } from '@atproto/syntax'
 import { DataPlaneClient } from '../data-plane/client'
-import { type CheckedFeatureGatesMap, FeatureGateID } from '../feature-gates'
+import { type CheckedFeatureGatesMap } from '../feature-gates/types'
 import { ids } from '../lexicon/lexicons'
 import { Record as ProfileRecord } from '../lexicon/types/app/bsky/actor/profile'
 import { isMain as isEmbedRecord } from '../lexicon/types/app/bsky/embed/record'
@@ -83,7 +83,13 @@ export class HydrateCtx {
   overrideIncludeTakedownsForActor = this.vals.overrideIncludeTakedownsForActor
   include3pBlocks = this.vals.include3pBlocks
   includeDebugField = this.vals.includeDebugField
-  featureGates: CheckedFeatureGatesMap = this.vals.featureGates || new Map()
+  /**
+   * Cache of evaluated feature gates to be used in a given request lifecycle.
+   * The actual evaluations happen at the top of the route handler and the
+   * results are stored in this map.
+   */
+  featureGatesMap: CheckedFeatureGatesMap =
+    this.vals.featureGatesMap || new Map()
   constructor(private vals: HydrateCtxVals) {}
   // Convenience with use with dataplane.getActors cache control
   get skipCacheForViewer() {
@@ -102,7 +108,7 @@ export type HydrateCtxVals = {
   overrideIncludeTakedownsForActor?: boolean
   include3pBlocks?: boolean
   includeDebugField?: boolean
-  featureGates?: CheckedFeatureGatesMap
+  featureGatesMap?: CheckedFeatureGatesMap
 }
 
 export type HydrationState = {
@@ -746,8 +752,8 @@ export class Hydrator {
     ctx: HydrateCtx,
   ): Promise<HydrationState> {
     const postsState = await this.hydratePosts(refs, ctx, undefined, {
-      processDynamicTagsForView: ctx.featureGates.get(
-        FeatureGateID.ThreadsReplyRankingExplorationEnable,
+      processDynamicTagsForView: ctx.featureGatesMap.get(
+        'threads:reply_ranking_exploration:enable',
       )
         ? 'thread'
         : undefined,
@@ -1331,7 +1337,7 @@ export class Hydrator {
       includeTakedowns: vals.includeTakedowns,
       include3pBlocks: vals.include3pBlocks,
       includeDebugField,
-      featureGates: vals.featureGates,
+      featureGatesMap: vals.featureGatesMap,
     })
   }
 

package/src/index.ts

@@ -23,7 +23,7 @@ import {
   createDataPlaneClient,
 } from './data-plane/client'
 import * as error from './error'
-import { FeatureGates } from './feature-gates'
+import { FeatureGatesClient } from './feature-gates'
 import { Hydrator } from './hydration/hydrator'
 import * as imageServer from './image/server'
 import { ImageUriBuilder } from './image/uri'
@@ -181,9 +181,10 @@ export class BskyAppView {
       entrywayJwtPublicKey,
     })
 
-    const featureGates = new FeatureGates({
-      apiHost: config.growthBookApiHost,
-      clientKey: config.growthBookClientKey,
+    const featureGatesClient = new FeatureGatesClient({
+      growthBookApiHost: config.growthBookApiHost,
+      growthBookClientKey: config.growthBookClientKey,
+      eventProxyTrackingEndpoint: config.eventProxyTrackingEndpoint,
     })
 
     const blobDispatcher = createBlobDispatcher(config)
@@ -205,7 +206,7 @@ export class BskyAppView {
       courierClient,
       rolodexClient,
       authVerifier,
-      featureGates,
+      featureGatesClient,
       blobDispatcher,
       kwsClient,
     })
@@ -241,7 +242,7 @@ export class BskyAppView {
     if (this.ctx.dataplaneHostList instanceof EtcdHostList) {
       await this.ctx.dataplaneHostList.connect()
     }
-    await this.ctx.featureGates.start()
+    this.ctx.featureGatesClient.start() // lazy, no await
     const server = this.app.listen(this.ctx.cfg.port)
     this.server = server
     server.keepAliveTimeout = 90000
@@ -253,7 +254,7 @@ export class BskyAppView {
   }
 
   async destroy(): Promise<void> {
-    this.ctx.featureGates.destroy()
+    this.ctx.featureGatesClient.destroy()
     await this.terminator?.terminate()
     await this.ctx.etcd?.close()
   }

package/src/lexicon/lexicons.ts

@@ -4947,6 +4947,10 @@ export const schemaDict = {
             type: 'object',
             required: ['interactions'],
             properties: {
+              feed: {
+                type: 'string',
+                format: 'at-uri',
+              },
               interactions: {
                 type: 'array',
                 items: {

package/src/lexicon/types/app/bsky/feed/sendInteractions.ts

@@ -18,6 +18,7 @@ const id = 'app.bsky.feed.sendInteractions'
 export type QueryParams = {}
 
 export interface InputSchema {
+  feed?: string
   interactions: AppBskyFeedDefs.Interaction[]
 }
 

package/src/views/index.ts

@@ -1,6 +1,5 @@
 import { HOUR, MINUTE, mapDefined } from '@atproto/common'
 import { AtUri, INVALID_HANDLE, normalizeDatetimeAlways } from '@atproto/syntax'
-import { FeatureGateID } from '../feature-gates'
 import { Actor, ProfileViewerState } from '../hydration/actor'
 import { FeedItem, Like, Post, Repost } from '../hydration/feed'
 import { Follow, Verification } from '../hydration/graph'
@@ -504,6 +503,10 @@ export class Views {
     const actor = state.actors?.get(did)
     if (!actor) return
 
+    // Currently, the handle comes as "handle.invalid" from the production dataplane.
+    // But the contract allows for empty handle, so we cover both cases.
+    if (!actor.handle || actor.handle === INVALID_HANDLE) return
+
     const isImpersonation = state.labels?.get(did)?.isImpersonation
 
     const verifications: VerificationView[] = actor.verifications.map(
@@ -1416,8 +1419,8 @@ export class Views {
         threadTagsHide: this.threadTagsHide,
         visibilityTagRankPrefix: this.visibilityTagRankPrefix,
       },
-      state.ctx?.featureGates.get(
-        FeatureGateID.ThreadsReplyRankingExplorationEnable,
+      state.ctx?.featureGatesMap.get(
+        'threads:reply_ranking_exploration:enable',
       ),
     )
 
@@ -1789,8 +1792,8 @@ export class Views {
         threadTagsHide: this.threadTagsHide,
         visibilityTagRankPrefix: this.visibilityTagRankPrefix,
       },
-      state.ctx?.featureGates.get(
-        FeatureGateID.ThreadsReplyRankingExplorationEnable,
+      state.ctx?.featureGatesMap.get(
+        'threads:reply_ranking_exploration:enable',
       ),
     )
   }
@@ -1987,9 +1990,7 @@ export class Views {
 
     let hiddenByTag = false
     if (
-      state.ctx?.featureGates.get(
-        FeatureGateID.ThreadsReplyRankingExplorationEnable,
-      )
+      state.ctx?.featureGatesMap.get('threads:reply_ranking_exploration:enable')
     ) {
       hiddenByTag = authorDid !== opDid && post.tags.has(this.visibilityTagHide)
     } else {

package/tests/views/thread.test.ts

@@ -568,6 +568,8 @@ describe('appview thread views', () => {
         sc.getHeaders(bob),
       )
 
+      await network.processAll()
+
       const threadBeforeListTakedown = await agent.app.bsky.feed.getPostThread(
         { depth: 1, uri: reply.ref.uriStr },
         {

package/tests/views/verification.test.ts

@@ -17,7 +17,7 @@ describe('verification views', () => {
   let network: TestNetwork
   let agent: AtpAgent
   let labelerDid: string
-  let sc: SeedClient
+  let sc: SeedClient<TestNetwork>
 
   // account dids, for convenience
   let alice: string
@@ -31,6 +31,8 @@ describe('verification views', () => {
   let verifier1: string
   let verifier2: string
   let verifier3: string
+  let handleinvalid: string
+  let handleempty: string
 
   beforeAll(async () => {
     network = await TestNetwork.create({
@@ -38,24 +40,11 @@ describe('verification views', () => {
     })
     agent = network.bsky.getClient()
     sc = network.getSeedClient()
-    await verificationsSeed(sc)
-
-    labelerDid = network.bsky.ctx.cfg.modServiceDid
-    await createLabel({
-      src: labelerDid,
-      uri: sc.dids.impersonator,
-      cid: '',
-      val: 'impersonation',
-    })
-    await createLabel({
-      src: labelerDid,
-      uri: sc.dids.verifier3,
-      cid: '',
-      val: 'impersonation',
-    })
 
+    await verificationsSeed(sc)
     await network.processAll()
 
+    labelerDid = network.bsky.ctx.cfg.modServiceDid
     alice = sc.dids.alice
     bob = sc.dids.bob
     carol = sc.dids.carol
@@ -67,6 +56,8 @@ describe('verification views', () => {
     verifier1 = sc.dids.verifier1
     verifier2 = sc.dids.verifier2
     verifier3 = sc.dids.verifier3
+    handleinvalid = sc.dids.handleinvalid
+    handleempty = sc.dids.handleempty
 
     await network.bsky.db.db
       .updateTable('actor')
@@ -241,6 +232,18 @@ describe('verification views', () => {
           `at://${verifier1}/app.bsky.graph.verification/`,
         ],
       },
+      {
+        description:
+          'returns undefined for user with invalid handle even if they have verifications',
+        getDid: () => handleinvalid,
+        getExpected: () => undefined,
+      },
+      {
+        description:
+          'returns undefined for user with empty handle even if they have verifications',
+        getDid: () => handleempty,
+        getExpected: () => undefined,
+      },
     ]
 
     it.each(testCases)(
@@ -277,25 +280,4 @@ describe('verification views', () => {
     )
     return res.data
   }
-
-  const createLabel = async (opts: {
-    src?: string
-    uri: string
-    cid: string
-    val: string
-    exp?: string
-  }) => {
-    await network.bsky.db.db
-      .insertInto('label')
-      .values({
-        uri: opts.uri,
-        cid: opts.cid,
-        val: opts.val,
-        cts: new Date().toISOString(),
-        exp: opts.exp ?? null,
-        neg: false,
-        src: opts.src ?? labelerDid,
-      })
-      .execute()
-  }
 })