8930368830

Committed 02 May 2024 08:59PM UTC coverage: 31.911% (-0.002%) from 31.913%

Build # 8930368830

Build Type

Pull #9215

github

Committed by

b0b3rt

Commit Message

add perf metrics for 3rd party recommendations

Pull Request Pull Request #9215: add perf metrics for 3rd party recommendations

Run Details

4726 of 38686 branches covered (12.22%)

Branch coverage included in aggregate %.

2 of 28 new or added lines in 3 files covered. (7.14%)

38 existing lines in 3 files now uncovered.

27578 of 62544 relevant lines covered (44.09%)

178.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

8.11

/packages/lesswrong/server/recombee/client.ts

import { ApiClient, RecommendationResponse, requests } from 'recombee-api-client';
import { HybridArmsConfig, HybridRecombeeConfiguration, RecombeeConfiguration, RecombeeRecommendationArgs } from '../../lib/collections/users/recommendationSettings';
import { loadByIds } from '../../lib/loaders';
import { filterNonnull } from '../../lib/utils/typeGuardUtils';
import { htmlToTextDefault } from '../../lib/htmlToText';
import { truncate } from '../../lib/editor/ellipsize';
import { accessFilterMultiple } from '../../lib/utils/schemaUtils';
import { recombeeDatabaseIdSetting, recombeePrivateApiTokenSetting } from '../../lib/instanceSettings';
import { viewTermsToQuery } from '../../lib/utils/viewUtils';
import { stickiedPostTerms } from '../../components/posts/RecombeePostsList';
import groupBy from 'lodash/groupBy';
import { recommendationsTabManuallyStickiedPostIdsSetting } from '../../lib/publicSettings';
import { closePerfMetric, getParentTraceId, openPerfMetric, wrapWithPerfMetric } from '../perfMetrics';

export const getRecombeeClientOrThrow = (() => {
  let client: ApiClient;

  return () => {
    if (!client) {
      const databaseId = recombeeDatabaseIdSetting.get();
      const apiToken = recombeePrivateApiTokenSetting.get();

      if (!databaseId || !apiToken) {
        throw new Error('Missing either databaseId or api token when initializing Recombee client!');
      }
      
      // TODO - pull out client options like region to db settings?
      client = new ApiClient(databaseId, apiToken, { region: 'us-west' });
    }

    return client;
  };
})();

const voteTypeRatingsMap: Partial<Record<string, number>> = {
  bigDownvote: -1,
  smallDownvote: -0.5,
  smallUpvote: 0.5,
  bigUpvote: 1,
};

const HYBRID_SCENARIO_MAP = {
  fixed: 'recombee-emulate-hacker-news',
  configurable: 'recombee-personal'
};

interface OnsitePostRecommendationsInfo {
  curatedPostIds: string[],
  stickiedPostIds: string[],
  excludedPostFilter?: string,
}

export interface RecombeeRecommendedPost {
  post: Partial<DbPost>,
  scenario: string,
  recommId: string,
  curated?: never,
  stickied?: never,
}

export type RecommendedPost = RecombeeRecommendedPost | {
  post: Partial<DbPost>,
  scenario?: never,
  recommId?: never,
  curated: boolean,
  stickied: boolean,
};

interface PostFieldDependencies {
  title: 'title',
  author: 'author',
  authorId: 'userId',
  karma: 'baseScore',
  body: 'contents',
  postedAt: 'postedAt',
  curated: 'curatedDate',
  frontpage: 'frontpageDate',
  draft: 'draft',
  lastCommentedAt: 'lastCommentedAt',
  shortform: 'shortform',
}

interface UpsertPostData<FieldMask extends PostFieldDependencies[keyof PostFieldDependencies] = PostFieldDependencies[keyof PostFieldDependencies]> {
  post: Pick<DbPost, FieldMask | '_id'>,
  tags: Pick<DbTag, 'name' | 'core'>[],
}

type RecRequest = requests.RecommendNextItems | requests.RecommendItemsToUser;

const recombeePostFieldMappings = {
  title:            ({ post }: UpsertPostData) => post.title,
  author:           ({ post }: UpsertPostData) => post.author,
  authorId:         ({ post }: UpsertPostData) => post.userId,
  karma:            ({ post }: UpsertPostData) => post.baseScore,
  body:             ({ post }: UpsertPostData) => htmlToTextDefault(truncate(post.contents?.html, 2000, 'words')),
  postedAt:         ({ post }: UpsertPostData) => post.postedAt,
  tags:             ({ tags }: UpsertPostData) => tags.map(tag => tag.name),
  coreTags:         ({ tags }: UpsertPostData) => tags.filter(tag => tag.core).map(tag => tag.name),
  curated:          ({ post }: UpsertPostData) => !!post.curatedDate,
  frontpage:        ({ post }: UpsertPostData) => !!post.frontpageDate,
  draft:            ({ post }: UpsertPostData) => !!post.draft,
  lastCommentedAt:  ({ post }: UpsertPostData) => post.lastCommentedAt,
  shortform:        ({ post }: UpsertPostData) => post.shortform,
};

type RecombeePostFields = keyof typeof recombeePostFieldMappings;

const ALL_RECOMBEE_POST_FIELDS = [
  'title', 'author', 'authorId', 'karma', 'body', 'postedAt', 'tags', 'coreTags',
  'curated', 'frontpage', 'draft', 'lastCommentedAt', 'shortform'
] as const;

const recombeeRequestHelpers = {
  createRecommendationsForUserRequest(userId: string, count: number, lwAlgoSettings: RecombeeRecommendationArgs) {
    const { userId: overrideUserId, rotationTime, lwRationalityOnly, onlyUnread, loadMore, ...settings } = lwAlgoSettings;

    if (loadMore) {
      return new requests.RecommendNextItems(loadMore.prevRecommId, count);
    }

    const servedUserId = overrideUserId ?? userId;
    const rotationTimeSeconds = typeof rotationTime === 'number' ? rotationTime * 3600 : undefined;

    // TODO: pass in scenario, exclude unread, etc, in options?
    const lwRationalityFilter = lwRationalityOnly ? ` and ("Rationality" in 'core_tags' or "World Modeling" in 'core_tags')` : '';

    return new requests.RecommendItemsToUser(servedUserId, count, {
      ...settings,
      // Explicitly coalesce empty strings to undefined, since empty strings aren't valid booster expressions
      booster: settings.booster || undefined,
      rotationTime: rotationTimeSeconds,
      cascadeCreate: true
    });
  },

  createUpsertPostRequest<Fields extends ReadonlyArray<RecombeePostFields>>(
    postData: UpsertPostData,
    fieldMask?: Fields,
    overrideOptions?: requests.SetValuesOptions
  ) {
    const { post } = postData;
    
    const recombeePostInfo = Object.fromEntries(
      (fieldMask ?? ALL_RECOMBEE_POST_FIELDS).map(field => [
        field,
        recombeePostFieldMappings[field](postData)
      ] as const)
    );

    return new requests.SetItemValues(post._id, recombeePostInfo, { cascadeCreate: true, ...overrideOptions });
  },

  createReadStatusRequest(readStatus: DbReadStatus) {
    if (!readStatus.postId) {
      // eslint-disable-next-line no-console
      console.error(`Missing postId for read status ${readStatus._id} when trying to add detail view to recombee`);
      return;
    }

    return new requests.AddDetailView(readStatus.userId, readStatus.postId, {
      timestamp: readStatus.lastUpdated.toISOString(),
      cascadeCreate: false
    });
  },

  createVoteRequest(vote: DbVote) {
    const rating = voteTypeRatingsMap[vote.voteType];
    if (typeof rating !== 'number') {
      // eslint-disable-next-line no-console
      console.log(`Attempted to create a recombee rating request for a non-karma vote with id ${vote._id}`);
      return;
    }

    return new requests.AddRating(vote.userId, vote.documentId, rating, {
      timestamp: vote.votedAt.toISOString(),
      cascadeCreate: false
    });
  },

  createUpsertUserDetailsRequest(user: DbUser) {
    const { displayName, karma, createdAt } = user;
    return new requests.SetUserValues(user._id, { displayName, karma, createdAt }, { cascadeCreate: true });
  },

  getBatchRequest(requestBatch: requests.Request[]) {
    return new requests.Batch(requestBatch);
  },

  async getOnsitePostInfo(lwAlgoSettings: HybridRecombeeConfiguration | RecombeeConfiguration, context: ResolverContext): Promise<OnsitePostRecommendationsInfo> {
    if (lwAlgoSettings.loadMore) {
      return {
        curatedPostIds: [],
        stickiedPostIds: [],
        excludedPostFilter: undefined,
      };
    }

    const postPromises =  [curatedPostTerms, stickiedPostTerms]
      .map(terms => viewTermsToQuery("Posts", terms, undefined, context))
      .map(postsQuery => context.Posts.find(postsQuery.selector, postsQuery.options, { _id: 1 }).fetch());

    const [curatedPosts, stickiedPosts] = await Promise.all(postPromises);

    const curatedPostIds = curatedPosts.map(post => post._id);
    const stickiedPostIds = stickiedPosts.map(post => post._id);
    const excludedPostIds = [...curatedPostIds, ...stickiedPostIds];
    const excludedPostFilter = `'itemId' not in {${excludedPostIds.map(id => `"${id}"`).join(', ')}}`;

    return {
      curatedPostIds,
      stickiedPostIds,
      excludedPostFilter,
    };
  },

  convertHybridToRecombeeArgs(hybridArgs: HybridRecombeeConfiguration, hybridArm: keyof HybridArmsConfig, filter?: string) {
    const { loadMore, userId, hybridScenarios, ...rest } = hybridArgs;

    const scenario = hybridScenarios[hybridArm];

    const isConfigurable = hybridArm === 'configurable';
    const clientConfig: Partial<Omit<HybridRecombeeConfiguration,"loadMore"|"userId">> = isConfigurable ? rest : {rotationRate: 0.1, rotationTime: 12};
    const prevRecommIdIndex = isConfigurable ? 0 : 1;
    const loadMoreConfig = loadMore
      ? { loadMore: { prevRecommId: loadMore.prevRecommIds[prevRecommIdIndex] } }
      : {};

    return {
      userId,
      ...clientConfig,
      filter,
      scenario,
      ...loadMoreConfig
    };
  },

  interleaveHybridRecommendedPosts(recommendedPosts: RecombeeRecommendedPost[]) {
    const recommendationGroupedPosts = groupBy(recommendedPosts, (result) => result.recommId);
    let weights = Object.entries(recommendationGroupedPosts).map(([recommId, posts]) => [recommId, posts.length / recommendedPosts.length] as const);

    const interleavedPosts: RecombeeRecommendedPost[] = [];

    while (interleavedPosts.length < recommendedPosts.length) {
      // Calculate current total weight (since it changes when we remove a recommId group for running out of posts)
      const totalWeight = weights.reduce((sum, [_, weight]) => sum + weight, 0);

      // Weighted random selection of next recommId to pick a post from
      let randomWeight = Math.random() * totalWeight;
      let selectedRecommId: string | undefined;
      for (const [recommId, recommIdWeight] of weights) {
        randomWeight -= recommIdWeight;
        if (randomWeight <= 0) {
          selectedRecommId = recommId;
          break;
        }
      }

      // Safety check, though selectedGroup should always be defined here
      if (!selectedRecommId) continue;

      // Add next post from the selected group to the interleaved array
      const postsWithRecommId = recommendationGroupedPosts[selectedRecommId];
      const nextPost = postsWithRecommId.shift();
      if (!nextPost) {
        // We shouldn't ever get here, but just in case
        continue;
      } else {
        interleavedPosts.push(nextPost);

        // Update the group's state: remove it if it's out of posts
        if (postsWithRecommId.length === 0) {
          weights = weights.filter(([recommId]) => recommId !== selectedRecommId);
        }  
      }
    }

    return interleavedPosts;
  },

  openHybridRecombeePerfMetric<T extends RecRequest>(firstRequest: T, secondRequest: T) {
    const firstRequestType = firstRequest.constructor.name;

    const opName = (firstRequest instanceof requests.RecommendNextItems || secondRequest instanceof requests.RecommendNextItems)
      ? `batch_${firstRequestType}`
      : `batch_${firstRequestType}_${firstRequest.bodyParameters().scenario ?? 'unknown'}_${secondRequest.bodyParameters().scenario ?? 'unknown'}`;

    return openPerfMetric({
      op_type: 'recombee',
      op_name: opName,
      ...getParentTraceId()
    });
  },
};

const curatedPostTerms: PostsViewTerms = {
  view: 'curated',
  limit: 3,
};

const recombeeApi = {
  async getRecommendationsForUser(userId: string, count: number, lwAlgoSettings: RecombeeRecommendationArgs, context: ResolverContext) {
    const client = getRecombeeClientOrThrow();

    const {
      curatedPostIds,
      stickiedPostIds,
      excludedPostFilter
    } = await recombeeRequestHelpers.getOnsitePostInfo(lwAlgoSettings, context);

    const curatedPostReadStatuses = await (
      lwAlgoSettings.loadMore
        ? Promise.resolve([])
        : context.ReadStatuses.find({ postId: { $in: curatedPostIds.slice(1) }, userId, isRead: true }).fetch()
    );

    const includedCuratedPostIds = curatedPostIds.filter(id => !curatedPostReadStatuses.find(readStatus => readStatus.postId === id));
    const curatedAndStickiedPostCount = includedCuratedPostIds.length + stickiedPostIds.length;

    const modifiedCount = count - curatedAndStickiedPostCount;
    const recommendationsRequestBody = recombeeRequestHelpers.createRecommendationsForUserRequest(userId, modifiedCount, { ...lwAlgoSettings, filter: excludedPostFilter });

    // We need the type cast here because recombee's type definitions can't handle inferring response types for union request types, even if they have the same response type
    const recombeeResponse = await client.send(recommendationsRequestBody) as RecommendationResponse;
    const { recomms, recommId } = recombeeResponse;

    const recommendationIdPairs = recomms.map(rec => [rec.id, recommId] as const);
    const recommendedPostIds = recomms.map(({ id }) => id);
    const postIds = [...includedCuratedPostIds, ...stickiedPostIds, ...recommendedPostIds];

    const posts = filterNonnull(await loadByIds(context, 'Posts', postIds));
    const filteredPosts = await accessFilterMultiple(context.currentUser, context.Posts, posts, context)

    const mappedPosts = filteredPosts.map(post => {
      // _id isn't going to be filtered out by `accessFilterMultiple`
      const postId = post._id!;
      const recommId = recommendationIdPairs.find(([id]) => id === postId)?.[1];
      if (recommId) {
        return { post, recommId, scenario: lwAlgoSettings.scenario };
      } else {
        return {
          post,
          curated: curatedPostIds.includes(postId),
          stickied: stickiedPostIds.includes(postId)  
        };
      }
    });

    return mappedPosts;
  },


  async getHybridRecommendationsForUser(userId: string, count: number, lwAlgoSettings: HybridRecombeeConfiguration, context: ResolverContext) {
    const client = getRecombeeClientOrThrow();

    const {
      curatedPostIds,
      stickiedPostIds,
      excludedPostFilter
    } = await recombeeRequestHelpers.getOnsitePostInfo(lwAlgoSettings, context);

    const manuallyStickiedPostIds = recommendationsTabManuallyStickiedPostIdsSetting.get()

    const curatedPostReadStatuses = await (
      lwAlgoSettings.loadMore
        ? Promise.resolve([])
        : context.ReadStatuses.find({ postId: { $in: curatedPostIds.slice(1) }, userId, isRead: true }).fetch()
    );

    const includedCuratedPostIds = curatedPostIds.filter(id => !curatedPostReadStatuses.find(readStatus => readStatus.postId === id));
    const curatedAndStickiedPostCount = includedCuratedPostIds.length + stickiedPostIds.length + manuallyStickiedPostIds.length;

    const modifiedCount = count - curatedAndStickiedPostCount;
    const split = 0.5;
    const firstCount = Math.floor(modifiedCount * split);
    const secondCount = modifiedCount - firstCount;

    const firstRequestSettings = recombeeRequestHelpers.convertHybridToRecombeeArgs(lwAlgoSettings, 'configurable', excludedPostFilter);
    const secondRequestSettings = recombeeRequestHelpers.convertHybridToRecombeeArgs(lwAlgoSettings, 'fixed', excludedPostFilter);

    const firstRequest = recombeeRequestHelpers.createRecommendationsForUserRequest(userId, firstCount, firstRequestSettings);
    const secondRequest = recombeeRequestHelpers.createRecommendationsForUserRequest(userId, secondCount, secondRequestSettings);
    const batchRequest = recombeeRequestHelpers.getBatchRequest([firstRequest, secondRequest]);
    
    const batchResponse = await wrapWithPerfMetric(
      () => client.send(batchRequest),
      () => recombeeRequestHelpers.openHybridRecombeePerfMetric(firstRequest, secondRequest)
    );
    // We need the type cast here because recombee's type definitions don't provide response types for batch requests
    const recombeeResponses = batchResponse.map(({json}) => json as RecommendationResponse);
    const recombeeResponsesWithScenario = recombeeResponses.map((response, index) => ({ ...response, scenario: index === 0 ? firstRequestSettings.scenario : secondRequestSettings.scenario }));

    // We explicitly avoid deduplicating postIds because we want to see how often the same post is recommended by both arms of the hybrid recommender
    const recommendationIdTuples = recombeeResponsesWithScenario.flatMap(response => response.recomms.map(rec => [rec.id, response.recommId, response.scenario] as const));
    const recommendedPostIds = recommendationIdTuples.map(([id]) => id);
    const postIds = [...includedCuratedPostIds, ...manuallyStickiedPostIds, ...stickiedPostIds, ...recommendedPostIds];
    
    const posts = filterNonnull(await loadByIds(context, 'Posts', postIds));
    const orderedPosts = filterNonnull(postIds.map(id => posts.find(post => post._id === id)));
    const filteredPosts = await accessFilterMultiple(context.currentUser, context.Posts, orderedPosts, context);

    const mappedPosts = filteredPosts.map(post => {
      // _id isn't going to be filtered out by `accessFilterMultiple`
      const postId = post._id!;
      const recommId = recommendationIdTuples.find(([id]) => id === postId)?.[1];
      const scenario = recommendationIdTuples.find(([id]) => id === postId)?.[2];

      if (recommId) {
        return { post, recommId, scenario };
      } else {
        const stickied = stickiedPostIds.includes(postId) || manuallyStickiedPostIds.includes(postId);
        if (stickied) {
          post.sticky = true;
        }

        return {
          post,
          curated: curatedPostIds.includes(postId),
          stickied  
        };
      }
    });

    const curatedOrStickiedPosts = mappedPosts.filter((result): result is Exclude<RecommendedPost, RecombeeRecommendedPost> => !result.recommId);
    const recommendedPosts = mappedPosts.filter((result): result is RecombeeRecommendedPost => !!result.recommId);

    const interleavedRecommendedPosts = recombeeRequestHelpers.interleaveHybridRecommendedPosts(recommendedPosts);

    return [...curatedOrStickiedPosts, ...interleavedRecommendedPosts];
  },


  async upsertPost(post: DbPost, context: ResolverContext) {
    const client = getRecombeeClientOrThrow();
    const { Tags } = context;

    const tagIds = Object.entries(post.tagRelevance ?? {}).filter(([_, relevance]: [string, number]) => relevance > 0).map(([tagId]) => tagId);
    const tags = filterNonnull(await loadByIds(context, 'Tags', tagIds));

    const request = recombeeRequestHelpers.createUpsertPostRequest({ post, tags });

    await client.send(request);
  },

  async createReadStatus(readStatus: DbReadStatus) {
    const client = getRecombeeClientOrThrow();
    const request = recombeeRequestHelpers.createReadStatusRequest(readStatus);
    if (!request) {
      return;
    }

    await client.send(request);
  },

  async createVote(vote: DbVote) {
    const client = getRecombeeClientOrThrow();
    const request = recombeeRequestHelpers.createVoteRequest(vote);
    if (!request) {
      return;
    }

    await client.send(request);
  },

  async createUser(user: DbUser) {
    const client = getRecombeeClientOrThrow();
    const request = recombeeRequestHelpers.createUpsertUserDetailsRequest(user);
    await client.send(request);
  }
};

export { recombeeRequestHelpers, recombeeApi };

1	import { ApiClient, RecommendationResponse, requests } from 'recombee-api-client';	54✔
2	import { HybridArmsConfig, HybridRecombeeConfiguration, RecombeeConfiguration, RecombeeRecommendationArgs } from '../../lib/collections/users/recommendationSettings';
3	import { loadByIds } from '../../lib/loaders';	18✔
4	import { filterNonnull } from '../../lib/utils/typeGuardUtils';	18✔
5	import { htmlToTextDefault } from '../../lib/htmlToText';	18✔
6	import { truncate } from '../../lib/editor/ellipsize';	18✔
7	import { accessFilterMultiple } from '../../lib/utils/schemaUtils';	18✔
8	import { recombeeDatabaseIdSetting, recombeePrivateApiTokenSetting } from '../../lib/instanceSettings';	18✔
9	import { viewTermsToQuery } from '../../lib/utils/viewUtils';	18✔
10	import { stickiedPostTerms } from '../../components/posts/RecombeePostsList';	18✔
11	import groupBy from 'lodash/groupBy';	18✔
12	import { recommendationsTabManuallyStickiedPostIdsSetting } from '../../lib/publicSettings';	18✔
13	import { closePerfMetric, getParentTraceId, openPerfMetric, wrapWithPerfMetric } from '../perfMetrics';	18✔
14
15	export const getRecombeeClientOrThrow = (() => {	18✔
16	let client: ApiClient;
17
18	return () => {	18✔
19	if (!client) {	×
20	const databaseId = recombeeDatabaseIdSetting.get();	×
21	const apiToken = recombeePrivateApiTokenSetting.get();	×
22
23	if (!databaseId \|\| !apiToken) {	×
24	throw new Error('Missing either databaseId or api token when initializing Recombee client!');	×
25	}
26
27	// TODO - pull out client options like region to db settings?
28	client = new ApiClient(databaseId, apiToken, { region: 'us-west' });	×
29	}
30
31	return client;	×
32	};
33	})();
34
35	const voteTypeRatingsMap: Partial<Record<string, number>> = {	18✔
36	bigDownvote: -1,
37	smallDownvote: -0.5,
38	smallUpvote: 0.5,
39	bigUpvote: 1,
40	};
41
42	const HYBRID_SCENARIO_MAP = {	18✔
43	fixed: 'recombee-emulate-hacker-news',
44	configurable: 'recombee-personal'
45	};
46
47	interface OnsitePostRecommendationsInfo {
48	curatedPostIds: string[],
49	stickiedPostIds: string[],
50	excludedPostFilter?: string,
51	}
52
53	export interface RecombeeRecommendedPost {
54	post: Partial<DbPost>,
55	scenario: string,
56	recommId: string,
57	curated?: never,
58	stickied?: never,
59	}
60
61	export type RecommendedPost = RecombeeRecommendedPost \| {
62	post: Partial<DbPost>,
63	scenario?: never,
64	recommId?: never,
65	curated: boolean,
66	stickied: boolean,
67	};
68
69	interface PostFieldDependencies {
70	title: 'title',
71	author: 'author',
72	authorId: 'userId',
73	karma: 'baseScore',
74	body: 'contents',
75	postedAt: 'postedAt',
76	curated: 'curatedDate',
77	frontpage: 'frontpageDate',
78	draft: 'draft',
79	lastCommentedAt: 'lastCommentedAt',
80	shortform: 'shortform',
81	}
82
83	interface UpsertPostData<FieldMask extends PostFieldDependencies[keyof PostFieldDependencies] = PostFieldDependencies[keyof PostFieldDependencies]> {
84	post: Pick<DbPost, FieldMask \| '_id'>,
85	tags: Pick<DbTag, 'name' \| 'core'>[],
86	}
87
88	type RecRequest = requests.RecommendNextItems \| requests.RecommendItemsToUser;
89
90	const recombeePostFieldMappings = {	18✔
91	title: ({ post }: UpsertPostData) => post.title,	×
92	author: ({ post }: UpsertPostData) => post.author,	×
93	authorId: ({ post }: UpsertPostData) => post.userId,	×
94	karma: ({ post }: UpsertPostData) => post.baseScore,	×
95	body: ({ post }: UpsertPostData) => htmlToTextDefault(truncate(post.contents?.html, 2000, 'words')),	×
96	postedAt: ({ post }: UpsertPostData) => post.postedAt,	×
97	tags: ({ tags }: UpsertPostData) => tags.map(tag => tag.name),	×
98	coreTags: ({ tags }: UpsertPostData) => tags.filter(tag => tag.core).map(tag => tag.name),	×
99	curated: ({ post }: UpsertPostData) => !!post.curatedDate,	×
100	frontpage: ({ post }: UpsertPostData) => !!post.frontpageDate,	×
101	draft: ({ post }: UpsertPostData) => !!post.draft,	×
102	lastCommentedAt: ({ post }: UpsertPostData) => post.lastCommentedAt,	×
103	shortform: ({ post }: UpsertPostData) => post.shortform,	×
104	};
105
106	type RecombeePostFields = keyof typeof recombeePostFieldMappings;
107
108	const ALL_RECOMBEE_POST_FIELDS = [	18✔
109	'title', 'author', 'authorId', 'karma', 'body', 'postedAt', 'tags', 'coreTags',
110	'curated', 'frontpage', 'draft', 'lastCommentedAt', 'shortform'
111	] as const;
112
113	const recombeeRequestHelpers = {	18✔
114	createRecommendationsForUserRequest(userId: string, count: number, lwAlgoSettings: RecombeeRecommendationArgs) {
115	const { userId: overrideUserId, rotationTime, lwRationalityOnly, onlyUnread, loadMore, ...settings } = lwAlgoSettings;	×
116
117	if (loadMore) {	×
118	return new requests.RecommendNextItems(loadMore.prevRecommId, count);	×
119	}
120
121	const servedUserId = overrideUserId ?? userId;	×
122	const rotationTimeSeconds = typeof rotationTime === 'number' ? rotationTime * 3600 : undefined;	×
123
124	// TODO: pass in scenario, exclude unread, etc, in options?
125	const lwRationalityFilter = lwRationalityOnly ? ` and ("Rationality" in 'core_tags' or "World Modeling" in 'core_tags')` : '';	×
126
127	return new requests.RecommendItemsToUser(servedUserId, count, {	×
128	...settings,
129	// Explicitly coalesce empty strings to undefined, since empty strings aren't valid booster expressions
130	booster: settings.booster \|\| undefined,	×
131	rotationTime: rotationTimeSeconds,
132	cascadeCreate: true
133	});
134	},
135
136	createUpsertPostRequest<Fields extends ReadonlyArray<RecombeePostFields>>(
137	postData: UpsertPostData,
138	fieldMask?: Fields,
139	overrideOptions?: requests.SetValuesOptions
140	) {
141	const { post } = postData;	×
142
143	const recombeePostInfo = Object.fromEntries(	×
144	(fieldMask ?? ALL_RECOMBEE_POST_FIELDS).map(field => [	×
145	field,
146	recombeePostFieldMappings[field](postData)
147	] as const)
148	);
149
150	return new requests.SetItemValues(post._id, recombeePostInfo, { cascadeCreate: true, ...overrideOptions });	×
151	},
152
153	createReadStatusRequest(readStatus: DbReadStatus) {
154	if (!readStatus.postId) {	×
155	// eslint-disable-next-line no-console
156	console.error(`Missing postId for read status ${readStatus._id} when trying to add detail view to recombee`);	×
157	return;	×
158	}
159
160	return new requests.AddDetailView(readStatus.userId, readStatus.postId, {	×
161	timestamp: readStatus.lastUpdated.toISOString(),
162	cascadeCreate: false
163	});
164	},
165
166	createVoteRequest(vote: DbVote) {
167	const rating = voteTypeRatingsMap[vote.voteType];	×
168	if (typeof rating !== 'number') {	×
169	// eslint-disable-next-line no-console
170	console.log(`Attempted to create a recombee rating request for a non-karma vote with id ${vote._id}`);	×
171	return;	×
172	}
173
174	return new requests.AddRating(vote.userId, vote.documentId, rating, {	×
175	timestamp: vote.votedAt.toISOString(),
176	cascadeCreate: false
177	});
178	},
179
180	createUpsertUserDetailsRequest(user: DbUser) {
181	const { displayName, karma, createdAt } = user;	×
182	return new requests.SetUserValues(user._id, { displayName, karma, createdAt }, { cascadeCreate: true });	×
183	},
184
185	getBatchRequest(requestBatch: requests.Request[]) {
186	return new requests.Batch(requestBatch);	×
187	},
188
189	async getOnsitePostInfo(lwAlgoSettings: HybridRecombeeConfiguration \| RecombeeConfiguration, context: ResolverContext): Promise<OnsitePostRecommendationsInfo> {
190	if (lwAlgoSettings.loadMore) {	×
191	return {	×
192	curatedPostIds: [],
193	stickiedPostIds: [],
194	excludedPostFilter: undefined,
195	};
196	}
197
198	const postPromises = [curatedPostTerms, stickiedPostTerms]	×
199	.map(terms => viewTermsToQuery("Posts", terms, undefined, context))	×
200	.map(postsQuery => context.Posts.find(postsQuery.selector, postsQuery.options, { _id: 1 }).fetch());	×
201
202	const [curatedPosts, stickiedPosts] = await Promise.all(postPromises);	×
203
204	const curatedPostIds = curatedPosts.map(post => post._id);	×
205	const stickiedPostIds = stickiedPosts.map(post => post._id);	×
206	const excludedPostIds = [...curatedPostIds, ...stickiedPostIds];	×
207	const excludedPostFilter = `'itemId' not in {${excludedPostIds.map(id => `"${id}"`).join(', ')}}`;	×
208
209	return {	×
210	curatedPostIds,
211	stickiedPostIds,
212	excludedPostFilter,
213	};
214	},
215
216	convertHybridToRecombeeArgs(hybridArgs: HybridRecombeeConfiguration, hybridArm: keyof HybridArmsConfig, filter?: string) {
217	const { loadMore, userId, hybridScenarios, ...rest } = hybridArgs;	×
218
219	const scenario = hybridScenarios[hybridArm];	×
220
221	const isConfigurable = hybridArm === 'configurable';	×
222	const clientConfig: Partial<Omit<HybridRecombeeConfiguration,"loadMore"\|"userId">> = isConfigurable ? rest : {rotationRate: 0.1, rotationTime: 12};	×
223	const prevRecommIdIndex = isConfigurable ? 0 : 1;	×
224	const loadMoreConfig = loadMore	×
225	? { loadMore: { prevRecommId: loadMore.prevRecommIds[prevRecommIdIndex] } }	×
226	: {};
227
228	return {	×
229	userId,
230	...clientConfig,
231	filter,
232	scenario,
233	...loadMoreConfig
234	};
235	},
236
237	interleaveHybridRecommendedPosts(recommendedPosts: RecombeeRecommendedPost[]) {
238	const recommendationGroupedPosts = groupBy(recommendedPosts, (result) => result.recommId);	×
239	let weights = Object.entries(recommendationGroupedPosts).map(([recommId, posts]) => [recommId, posts.length / recommendedPosts.length] as const);	×
240
241	const interleavedPosts: RecombeeRecommendedPost[] = [];	×
242
243	while (interleavedPosts.length < recommendedPosts.length) {	×
244	// Calculate current total weight (since it changes when we remove a recommId group for running out of posts)
245	const totalWeight = weights.reduce((sum, [_, weight]) => sum + weight, 0);	×
246
247	// Weighted random selection of next recommId to pick a post from
248	let randomWeight = Math.random() * totalWeight;	×
249	let selectedRecommId: string \| undefined;
250	for (const [recommId, recommIdWeight] of weights) {	×
251	randomWeight -= recommIdWeight;	×
252	if (randomWeight <= 0) {	×
253	selectedRecommId = recommId;	×
254	break;	×
255	}
256	}
257
258	// Safety check, though selectedGroup should always be defined here
259	if (!selectedRecommId) continue;	×
260
261	// Add next post from the selected group to the interleaved array
262	const postsWithRecommId = recommendationGroupedPosts[selectedRecommId];	×
263	const nextPost = postsWithRecommId.shift();	×
264	if (!nextPost) {	×
265	// We shouldn't ever get here, but just in case
266	continue;	×
267	} else {
268	interleavedPosts.push(nextPost);	×
269
270	// Update the group's state: remove it if it's out of posts
271	if (postsWithRecommId.length === 0) {	×
272	weights = weights.filter(([recommId]) => recommId !== selectedRecommId);	×
273	}
274	}
275	}
276
277	return interleavedPosts;	×
278	},
279
280	openHybridRecombeePerfMetric<T extends RecRequest>(firstRequest: T, secondRequest: T) {
NEW 281	const firstRequestType = firstRequest.constructor.name;	×
282
NEW 283	const opName = (firstRequest instanceof requests.RecommendNextItems \|\| secondRequest instanceof requests.RecommendNextItems)	×
284	? `batch_${firstRequestType}`	×
285	: `batch_${firstRequestType}_${firstRequest.bodyParameters().scenario ?? 'unknown'}_${secondRequest.bodyParameters().scenario ?? 'unknown'}`;	×
286
NEW 287	return openPerfMetric({	×
288	op_type: 'recombee',
289	op_name: opName,
290	...getParentTraceId()
291	});
292	},
293	};
294
295	const curatedPostTerms: PostsViewTerms = {	18✔
296	view: 'curated',
297	limit: 3,
298	};
299
300	const recombeeApi = {	18✔
301	async getRecommendationsForUser(userId: string, count: number, lwAlgoSettings: RecombeeRecommendationArgs, context: ResolverContext) {
302	const client = getRecombeeClientOrThrow();	×
303
304	const {
305	curatedPostIds,
306	stickiedPostIds,
307	excludedPostFilter
308	} = await recombeeRequestHelpers.getOnsitePostInfo(lwAlgoSettings, context);	×
309
310	const curatedPostReadStatuses = await (	×
311	lwAlgoSettings.loadMore
312	? Promise.resolve([])	×
313	: context.ReadStatuses.find({ postId: { $in: curatedPostIds.slice(1) }, userId, isRead: true }).fetch()
314	);
315
316	const includedCuratedPostIds = curatedPostIds.filter(id => !curatedPostReadStatuses.find(readStatus => readStatus.postId === id));	×
317	const curatedAndStickiedPostCount = includedCuratedPostIds.length + stickiedPostIds.length;	×
318
319	const modifiedCount = count - curatedAndStickiedPostCount;	×
320	const recommendationsRequestBody = recombeeRequestHelpers.createRecommendationsForUserRequest(userId, modifiedCount, { ...lwAlgoSettings, filter: excludedPostFilter });	×
321
322	// We need the type cast here because recombee's type definitions can't handle inferring response types for union request types, even if they have the same response type
323	const recombeeResponse = await client.send(recommendationsRequestBody) as RecommendationResponse;	×
324	const { recomms, recommId } = recombeeResponse;	×
325
326	const recommendationIdPairs = recomms.map(rec => [rec.id, recommId] as const);	×
327	const recommendedPostIds = recomms.map(({ id }) => id);	×
328	const postIds = [...includedCuratedPostIds, ...stickiedPostIds, ...recommendedPostIds];	×
329
330	const posts = filterNonnull(await loadByIds(context, 'Posts', postIds));	×
331	const filteredPosts = await accessFilterMultiple(context.currentUser, context.Posts, posts, context)	×
332
333	const mappedPosts = filteredPosts.map(post => {	×
334	// _id isn't going to be filtered out by `accessFilterMultiple`
335	const postId = post._id!;	×
336	const recommId = recommendationIdPairs.find(([id]) => id === postId)?.[1];	×
337	if (recommId) {	×
338	return { post, recommId, scenario: lwAlgoSettings.scenario };	×
339	} else {
340	return {	×
341	post,
342	curated: curatedPostIds.includes(postId),
343	stickied: stickiedPostIds.includes(postId)
344	};
345	}
346	});
347
348	return mappedPosts;	×
349	},
350
351
352	async getHybridRecommendationsForUser(userId: string, count: number, lwAlgoSettings: HybridRecombeeConfiguration, context: ResolverContext) {
353	const client = getRecombeeClientOrThrow();	×
354
355	const {
356	curatedPostIds,
357	stickiedPostIds,
358	excludedPostFilter
359	} = await recombeeRequestHelpers.getOnsitePostInfo(lwAlgoSettings, context);	×
360
361	const manuallyStickiedPostIds = recommendationsTabManuallyStickiedPostIdsSetting.get()	×
362
363	const curatedPostReadStatuses = await (	×
364	lwAlgoSettings.loadMore
365	? Promise.resolve([])	×
366	: context.ReadStatuses.find({ postId: { $in: curatedPostIds.slice(1) }, userId, isRead: true }).fetch()
367	);
368
369	const includedCuratedPostIds = curatedPostIds.filter(id => !curatedPostReadStatuses.find(readStatus => readStatus.postId === id));	×
370	const curatedAndStickiedPostCount = includedCuratedPostIds.length + stickiedPostIds.length + manuallyStickiedPostIds.length;	×
371
372	const modifiedCount = count - curatedAndStickiedPostCount;	×
373	const split = 0.5;	×
374	const firstCount = Math.floor(modifiedCount * split);	×
375	const secondCount = modifiedCount - firstCount;	×
376
377	const firstRequestSettings = recombeeRequestHelpers.convertHybridToRecombeeArgs(lwAlgoSettings, 'configurable', excludedPostFilter);	×
378	const secondRequestSettings = recombeeRequestHelpers.convertHybridToRecombeeArgs(lwAlgoSettings, 'fixed', excludedPostFilter);	×
379
380	const firstRequest = recombeeRequestHelpers.createRecommendationsForUserRequest(userId, firstCount, firstRequestSettings);	×
381	const secondRequest = recombeeRequestHelpers.createRecommendationsForUserRequest(userId, secondCount, secondRequestSettings);	×
382	const batchRequest = recombeeRequestHelpers.getBatchRequest([firstRequest, secondRequest]);	×
383
NEW 384	const batchResponse = await wrapWithPerfMetric(	×
NEW 385	() => client.send(batchRequest),	×
NEW 386	() => recombeeRequestHelpers.openHybridRecombeePerfMetric(firstRequest, secondRequest)	×
387	);
388	// We need the type cast here because recombee's type definitions don't provide response types for batch requests
389	const recombeeResponses = batchResponse.map(({json}) => json as RecommendationResponse);	×
390	const recombeeResponsesWithScenario = recombeeResponses.map((response, index) => ({ ...response, scenario: index === 0 ? firstRequestSettings.scenario : secondRequestSettings.scenario }));	×
391
392	// We explicitly avoid deduplicating postIds because we want to see how often the same post is recommended by both arms of the hybrid recommender
393	const recommendationIdTuples = recombeeResponsesWithScenario.flatMap(response => response.recomms.map(rec => [rec.id, response.recommId, response.scenario] as const));	×
394	const recommendedPostIds = recommendationIdTuples.map(([id]) => id);	×
395	const postIds = [...includedCuratedPostIds, ...manuallyStickiedPostIds, ...stickiedPostIds, ...recommendedPostIds];	×
396
397	const posts = filterNonnull(await loadByIds(context, 'Posts', postIds));	×
398	const orderedPosts = filterNonnull(postIds.map(id => posts.find(post => post._id === id)));	×
399	const filteredPosts = await accessFilterMultiple(context.currentUser, context.Posts, orderedPosts, context);	×
400
401	const mappedPosts = filteredPosts.map(post => {	×
402	// _id isn't going to be filtered out by `accessFilterMultiple`
403	const postId = post._id!;	×
404	const recommId = recommendationIdTuples.find(([id]) => id === postId)?.[1];	×
405	const scenario = recommendationIdTuples.find(([id]) => id === postId)?.[2];	×
406
407	if (recommId) {	×
408	return { post, recommId, scenario };	×
409	} else {
410	const stickied = stickiedPostIds.includes(postId) \|\| manuallyStickiedPostIds.includes(postId);	×
411	if (stickied) {	×
412	post.sticky = true;	×
413	}
414
415	return {	×
416	post,
417	curated: curatedPostIds.includes(postId),
418	stickied
419	};
420	}
421	});
422
423	const curatedOrStickiedPosts = mappedPosts.filter((result): result is Exclude<RecommendedPost, RecombeeRecommendedPost> => !result.recommId);	×
424	const recommendedPosts = mappedPosts.filter((result): result is RecombeeRecommendedPost => !!result.recommId);	×
425
426	const interleavedRecommendedPosts = recombeeRequestHelpers.interleaveHybridRecommendedPosts(recommendedPosts);	×
427
428	return [...curatedOrStickiedPosts, ...interleavedRecommendedPosts];	×
429	},
430
431
432	async upsertPost(post: DbPost, context: ResolverContext) {
433	const client = getRecombeeClientOrThrow();	×
434	const { Tags } = context;	×
435
436	const tagIds = Object.entries(post.tagRelevance ?? {}).filter(([_, relevance]: [string, number]) => relevance > 0).map(([tagId]) => tagId);	×
437	const tags = filterNonnull(await loadByIds(context, 'Tags', tagIds));	×
438
439	const request = recombeeRequestHelpers.createUpsertPostRequest({ post, tags });	×
440
441	await client.send(request);	×
442	},
443
444	async createReadStatus(readStatus: DbReadStatus) {
445	const client = getRecombeeClientOrThrow();	×
446	const request = recombeeRequestHelpers.createReadStatusRequest(readStatus);	×
447	if (!request) {	×
448	return;	×
449	}
450
451	await client.send(request);	×
452	},
453
454	async createVote(vote: DbVote) {
455	const client = getRecombeeClientOrThrow();	×
456	const request = recombeeRequestHelpers.createVoteRequest(vote);	×
457	if (!request) {	×
458	return;	×
459	}
460
461	await client.send(request);	×
462	},
463
464	async createUser(user: DbUser) {
465	const client = getRecombeeClientOrThrow();	×
466	const request = recombeeRequestHelpers.createUpsertUserDetailsRequest(user);	×
467	await client.send(request);	×
468	}
469	};
470
471	export { recombeeRequestHelpers, recombeeApi };

ForumMagnum / ForumMagnum / 8930368830

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous