crbench//

qodo

Latest run 2026-10-25 · website ↗

37%
Rating · High
95% 31%–43% · 1016 matchups
56.1%
Coverage
66.3%
Cross-File
20/37
Security
50% severity-weighted
94.6%
Validity
5.3%
False-alarms
127
Cases (100%)

Head-to-head — compare defect-by-defect

vs Claude Code (Opus 5.5)vs Cubicvs cursorvs Drape (Deep Review)vs Drape (Review)vs greptilevs Mjolnir (Opus 5.5)vs Mjolnir (Sonnet 5.5)

Coverage by severity — expand a row to see what it missed

critical 0/5 (0.0%)
The diff replaces the TOTP branch with `if (user.twoFactorEnabled && credentials.backupCode)`, which takes priority over TOTP verification, while the unchanged password gate above it verifies the password only when `totpCode` is falsy (`if (user.password && !credentials.totpCode)`). Posting an email, any non-empty `totpCode`, and a stolen backup code therefore skips the password check and authenticates on the backup code alone, without the password and without ever reaching TOTP verification.
New migration line 11 does `execute("...INNER JOIN site_settings...WHERE s.name='embed_category'")[0]['id']`, but installs that never overrode the `embed_category` setting (default '') have no such row, so the query returns zero rows and `[0]` raises IndexError, aborting the upgrade migration.
maybeDoSizeFlush assigns `lastFile.Span.EndKey = newSpan.Key` without cloning, but newSpan.Key aliases the caller's reused scratch buffer in compactSpanEntry. The next WriteKey overwrites scratch in place, silently mutating the already-recorded EndKey and producing BackupManifest_File entries with overlapping/drifted spans (corrupted backup metadata). Sibling Reset paths in the same file clone correctly; maybeDoSizeFlush was missed.
`getStatsForStmtWithKey` returns the nil zero value when the key is absent and `createIfNonexistent` is false, and the diff adds an early return in `recordStatement` that dereferences it unconditionally (`if !createIfNonExistent { return s.ID }`). A statement first seen at or below the configured latency threshold therefore panics with a nil pointer dereference.
The new response-pipeline webhook delivery job (process-response-pipeline-job.ts) calls validateWebhookUrl(webhook.url) and then issues a plain fetchWithTimeout(webhook.url, ...) with no pinned dispatcher/agent and no manual redirect handling. The validate-then-default-fetch sequence leaves a DNS-rebinding TOCTOU window (the URL re-resolves on the real request) and follows 30x redirects, so an attacker-controlled webhook can reach internal services and cloud metadata endpoints (SSRF). Fixed by #8095 by pinning the resolved IP via a custom dispatcher and setting redirect to manual on delivery.
high 70/108 (64.8%)
Potential null reference if mainHostDestinationCalendar is undefined if evt.destinationCalendar is null or an empty array
Logic inversion in organization creation: The slug property is now conditionally set when IS_TEAM_BILLING_ENABLED is true, instead of when it's false as originally intended. This change, combined with requestedSlug still being set when IS_TEAM_BILLING_ENABLED is true, results in both properties being set when billing is enabled, and neither when disabled
At handleNewBooking.ts:1063-1067 evt.destinationCalendar is set to null when neither eventType nor organizerUser has a destinationCalendar, so the COLLECTIVE branch's `evt.destinationCalendar?.push(...teamDestinationCalendars)` (line 1078) short-circuits to a no-op, silently discarding all team members' destinationCalendars and producing no calendar events for them.
EventManager.ts:170 now writes credentialId: undefined for video booking references (was result.credentialId from videoClient.ts:78), so handleCancelBooking.ts:491's `if (bookingVideoReference.credentialId)` guard is always false and the external video meeting is never deleted on cancellation.
The new line `if (response.statusText !== "OK")` in salesforce CalendarService.getClient checks statusText, but Node's global fetch (undici) returns an empty statusText for HTTP/2 responses served by login.salesforce.com, so a successful 200 yields `"" !== "OK"` and throws HttpError on every Salesforce client construction.
The deleteMany OR-arm `retryCount: { gt: 1 }` has no method or scheduledDate filter, so an SMS reminder retried more than once is deleted even when its scheduled date is still in the future, prematurely removing pending reminders.
scheduleSMS returns undefined on SMS-lock and throws on rate-limit/missing-creds; both paths increment retryCount, and the new deleteMany OR clause (retryCount > 1, with no method/date filter) permanently deletes those reminders after a few cron runs, so transient locks, monthly rate-limits, or a temporary Twilio misconfiguration silently drop reminders that previously stayed scheduled=false and were retried until scheduledDate.
The new migration inserts each newline-split token of the old `embeddable_hosts` site-setting value directly into a raw SQL string: `execute "INSERT INTO embeddable_hosts (host, category_id, created_at, updated_at) VALUES ('#{h}', #{category_id}, ...)"`. `h` is unsanitized admin-controlled free text (the setting had no hostname validation); a value containing a single quote (an accidental typo or a deliberate payload) produces malformed SQL or executes arbitrary statements. Migrations run with DDL-capable database credentials, so the blast radius is large.
TopicRetriever fetches the embed/feed URL with `open(url).read` (Readability) and `open(SiteSetting.feed_polling_url)`. The only guard is `invalid_host?`, which pins the initial referer/embeddable_host; open-uri transparently follows HTTP redirects, so a whitelisted host returning a 3xx to an internal address (link-local 169.254.169.254, a private IP, or a localhost admin port) reaches it. This is a redirect-based SSRF that the host whitelist does not cover.
The TopicEmbed.import method is susceptible to a NoMethodError if the contents parameter is nil when attempting to append a string, and an XSS vulnerability due to unescaped url interpolation in the generated HTML.
poll_feed.rb passes raw third-party feed HTML to TopicEmbed.import with cook_method raw_html, which post.rb's cook() returns verbatim without sanitization (unlike import_remote's Readability whitelist), and best.html.erb renders it via `raw post.cooked` on a Discourse-origin page with X-Frame-Options ALLOWALL — yielding stored XSS from `<script>` in a feed item.
The change narrows shouldShowSyncColumns() with `&& conn.supportsColumnSelection`, which is correct for the column-selection control. But the unchanged consumer wizard.ts uses that same gate to show the sync-method and primary-key controls too. For any connector that does not support column selection, those two controls now silently disappear, so the user can no longer choose incremental vs full-refresh sync. The fix is a separate gate for column selection.
The change adds the assertSameEnv() environment-scoping guard to the create() and update() mutations, but the sibling remove() on the same controller is left unguarded. An API key scoped to one environment can therefore delete an integration in another environment of the same org (a cross-environment IDOR). The vulnerable line is the unchanged remove(): the diff shows the guard being added to its siblings, not to it.
In listWithTeamHandler (packages/trpc/server/routers/viewer/eventTypes/listWithTeam.handler.ts), this PR adds `AND "public"."EventType"."teamId" IS NULL` to the WHERE clause of Part 1 of the raw SQL UNION query. Part 1 previously returned every EventType owned by the current user (`userId = currentUser`); the new condition restricts it to non-team event types only. Team event types are then expected to come from Part 2, which discovers them via an INNER JOIN on Membership. But a team event type whose `userId` is set to the current user while that user has no Membership row for the team falls through both branches: Part 1 excludes it (teamId is not null) and Part 2 excludes it (no Membership). The result is that such owned team event types silently disappear from the listing, breaking the event-types view for owners-without-membership.
In useBookings, this PR renames the instant-booking query parameter from bookingId (a number) to bookingUid (a string), but the getInstantBookingLocation query is still gated only on `enabled: !!bookingUid` with no isInstantMeeting guard. A non-instant "additional seats" booking flow carries a bookingUid in the URL (Booker store setSeatedEventData), so the query now fires for it; when the existing booking's metadata has a videoCallUrl, RedirectToInstantMeetingModal pushes the booker to that video page, and otherwise an error toast shows. Either way the seat cannot be booked. Before the rename the value was read as `parseInt(getQueryParam("bookingId") ?? "0")`, which was 0 (falsy, query disabled) on those URLs, so the rename is what newly triggers the path. The fix gates both the query and the redirect effect on isInstantMeeting.
sameElidedPrefix(newSpan.Key, lastFile.Span.EndKey, ...) is structurally always true in the contiguous-extend path, since isContiguousSpan requires newSpan.Key == lastFile.Span.EndKey by definition -- comparing ElidedPrefix(X) to itself. The guard therefore cannot fire on the exact path it exists to protect: extending a manifest file across a contiguous span whose elided prefix differs from s.elidedPrefix silently mislabels the entry's key-strip prefix, corrupting restore for ordinary backup shapes (a table's span ending where the next table's begins). Distinct from d1 -- same function, different mechanism. The sibling file_sst_sink.go compares spanPrefix against s.elidedPrefix directly and does not have this bug.
getDeleter re-acquires when `!timestamp.After(expiration)` (timestamp <= expiration), which is the lease's valid range, so it re-leases every call while valid and reuses the expired descriptor (setting a past UpdateDeadline) once timestamp > expiration — inverted relative to hasExpired's `expiration.LessEq(timestamp)`.
`updateTombstone` guards with `if err != nil && isLwwLoser(err)` and then re-tests `if isLwwLoser(err)` inside that branch, which is always true, making the `return batchStats{}, err` arm unreachable. The consequence is the fall-through: any genuine error (addToBatch failure, `txn.KV().Run` failure, a lease error) fails the outer condition and reaches `return batchStats{}, nil`, reporting success on a failed tombstone update.
The refactor moved the interval guard into canSave as `if interval <= 0 { return false }`, but min_checkpoint_frequency=0 is a valid setting meaning 'save as often as possible.' `<= 0` folds the zero case into the disabled case, so the changefeed highwater never advances and resolved timestamps are never emitted. The fix is `<= 0` -> `< 0`.
In the new Index.check() (django/db/models/indexes.py), the local-field validation passes the raw self.fields set to model._check_local_fields: "{*self.fields, *self.include, *references}". self.fields keeps the leading "-" descending-ordering prefix, whereas the old Model._check_indexes built the field list from index.fields_orders (which strips the prefix). So an index declared with a descending field, e.g. Index(fields=["-author"]), is looked up as "-author", fails to match the real "author" field, and raises a spurious models.E012 ("indexes refers to the nonexistent field -author") on a perfectly valid model.
This PR renames the private storage download/delete route from a single-segment [fileName] dynamic parameter to a catch-all [...filePath], specifically so it can also serve the newly introduced /storage/{workspaceId}/private/surveys/{surveyId}/elements/{elementId}/{file} scoped upload paths (per the PR's own description: "Scope new private upload URLs under .../surveys/{surveyId}/elements/{elementId}/..."). Both the nested route shape and the underlying storage key scheme for element-scoped uploads are new in this diff. Routing these newly introduced, more sensitive per-response upload files through the SAME entry point -- still gated only by the pre-existing, role-blind hasUserWorkspaceAccess (see d1) -- exposes them to billing-role users for the first time. This is a diff-attributable widening of exposure, distinct from d1's own (pre-existing, unchanged) check logic: unlike d1, this defect is genuinely introduced by the diff and should not be excluded from headline scoring.
All four write methods now hand the legacy write to a goroutine whose context descends from the request context (`context.WithTimeoutCause(ctx, ...)`). net/http cancels the request context as soon as the handler returns, and the goroutine starts microseconds before that, so the legacy write is aborted mid-flight on essentially every request and unified storage silently diverges from legacy storage.
The informer transform `trim` calls `accessor.SetManagedFields(nil)` unconditionally on every resync, mutating the object that lives in the shared informer cache. Because that cached object is read concurrently by other informer consumers, the unconditional in-place mutation is a data race that can panic kube-controller-manager / scheduler. The fix guards it (`if accessor.GetManagedFields() != nil`) so the transform is idempotent and does not rewrite shared state when already trimmed.
In `prepareResources`, the branch that handles an already-prepared claim (`if claimInfo.isPrepared()`) does `return nil` instead of `continue`. Because this runs inside the `for ... range pod.Spec.ResourceClaims` loop, the first already-prepared claim short-circuits the whole loop and the pod's remaining ResourceClaims are never prepared. The fix changes `return nil` back to `continue`.
The new pod index `AddPodControllerUIDIndexer` / `PodControllerUIDIndex` keys solely on the owning controllerRef's UID (`[]string{string(ref.UID)}`), ignoring namespace, kind, and name. Controllers (DaemonSet/ReplicaSet/Job/StatefulSet) that look pods up through this index can claim the wrong pods when a stale or duplicated ownerReference UID collides. The fix re-keys the index on the full (namespace, kind, name, uid) tuple.
Passing `nextConfig: __NEXT_HAS_REWRITES ? undefined : nextConfig` to getNextPathnameInfo was meant to preserve the locale prefix, but disabling the whole config also disables basePath stripping. The `/_next/data/<buildId>/...` prefix is never removed, and on a catch-all route the route regex overwrites router.query.<param> with the leftover data-URL segments, producing malformed URLs and 404s when basePath + rewrites + middleware + dynamic routes combine.
The response-handling refactor builds the /_next/data JSON page response as Buffer.from(JSON.stringify(result.value.pageData)). RenderResult.isDynamic decides static-vs-dynamic via `typeof this.response !== 'string'`, so a Buffer is misclassified as a dynamic stream; sendRenderResult then skips Content-Length and ETag and falls back to Transfer-Encoding: chunked, breaking CDN-side compression for self-hosted Pages Router deploys. The fix deletes the Buffer.from wrapper. (Large-diff stress case: ~3k lines, 22 files.)
In the app-route template's on-demand-revalidate path, responseGenerator correctly writes a real 404 response (res.statusCode = 404; res.end(...)) and returns null when isOnDemandRevalidate && revalidateOnlyGenerated && !previousCacheEntry. Back in handleResponse, because this route is ISR-eligible (isIsr is true -- it's determined solely by prerender-manifest membership, independent of the on-demand-revalidate flags, and on-demand revalidation is inherently an ISR-only feature), the `if (!isIsr) return null` short-circuit is skipped, and cacheEntry?.value?.kind !== CachedRouteKind.APP_ROUTE (true, since cacheEntry is null) throws an "Invariant: app-route received invalid cache entry" error -- even though a valid 404 HTTP response was already sent to the client. Because isIsr is true, the surrounding catch re-throws this spurious error rather than swallowing it, propagating it up through base-server onto an already-ended response.
With `trailingSlash: true`, the new handler templates (app-page.ts, app-route.ts, pages.ts) take `resolvedPathname` from the request URL, which base-server now rebuilds from the raw `initURL` and which still ends in a slash. None of them calls `removeTrailingSlash`, which base-server applied before its cache-key and prerender lookups. The build writes prerender-manifest keys without the slash, so every lookup misses. For app-page, a prerendered page on a `dynamicParams = false` route is taken to be unlisted and throws NoFallbackError (404), and the ISR cache key becomes `/blog/a/`, so the prebuilt output is never served.
The re-implemented Server Action reducer now rejects the action's promise with a redirect error for every redirect, external ones included, where it previously resolved them, and builds that error's URL with createHrefFromUrl, which keeps only the path and query, so an external URL loses its origin. Called from a form action or useTransition, React catches the handled error and the external navigation that handleExternalUrl staged (mpaNavigation) goes through. Called outside a React scope, such as a plain onClick, the rejection reaches the app router's unhandledrejection handler, which pushes the same-origin path; that navigation supersedes the external one, so the redirect to the external URL never happens.
The PR added API-key environment scoping to only the create and update integration routes. The sibling mutations removeIntegration, setIntegrationAsPrimary, and autoConfigureIntegration on the same controller were left unscoped, so an API key from one environment can delete, re-prioritize, or auto-configure integrations in another environment of the same org (cross-environment IDOR).
The change narrows shouldShowSyncColumns with `&& selectedConnector.supportsColumnSelection`, correct for column-selection but the same flag also gates the Sync-method, Sync-field, and Primary-key columns. supportsColumnSelection is false for all non-SQL sources (Stripe, Hubspot, REST), so those three controls silently disappeared for every non-SQL source during table setup.
A new usage-report query runs raw `FROM logs` through sync_execute() on the logs cluster. HogQL resolves its `logs` table to the physical `logs_distributed` table, and production's logs cluster has no table named `logs`: the `logs` Distributed table that migration 0214 creates exists only in local and test schemas, which is why the PR's test passes. In production the query fails, and since the new query runs unconditionally it aborts the whole usage-report run that feeds billing (reverted the next day in #60611).
In `src/sentry/utils/samples.py`, `measurements.update(measurement_markers)` is placed INSIDE the `for key, entry in measurements.items()` loop, mutating the dict that is being iterated. Adding the new `mark.*` keys mid-iteration raises `RuntimeError: dictionary changed size during iteration`, breaking `load_data` for any transaction that carries measurements. The fix dedents the update to run once after the loop.
MetricAlertDetectorHandler inherits from StatefulDetectorHandler but only contains pass, failing to implement its required abstract methods: counter_names (property), get_dedupe_value(), get_group_key_values(), and build_occurrence_and_event_data(). This will cause a TypeError at runtime when the class is instantiated.
Because flusher processes are created via multiprocessing.get_context('spawn').Process, they are instances of multiprocessing.context.SpawnProcess, which on POSIX is not a subclass of multiprocessing.Process, so this isinstance check will always be false and hung processes won't be killed here.
In pkg/querier/postprocess.go the new prepareFillZeroArgsWithStep builds the fillZero function args as {req.Start, req.End, step} where step is computed in milliseconds (query.StepInterval.Duration.Milliseconds()) but req.Start/req.End are not guaranteed to be in milliseconds at runtime (callers may pass nanosecond-resolution timestamps). funcFillZero requires all three args in the same unit and loops from start to end by step appending one point per iteration; when start/end are nanoseconds and step is milliseconds the iteration count is ~10^6x too large, so the fill-zero path allocates an enormous slice of zero points and blows up memory / OOMs the query service.
The new eventDecoder builds each event's row from `getPhysicalColumnsSchema`, which drops every computed column, stored ones included. When the crud writer applies a replicated delete for a row the destination does not have, the table handler passes that row to `tombstoneUpdater.updateTombstone`. The tombstone updater's row.Deleter is built from `writeableColunms`, which keeps stored computed columns, and indexes the row by position. On a table with a stored computed column, every later column's datum is shifted. For example, on `(k INT PRIMARY KEY, c INT AS (k+1) STORED, v INT, INDEX (v))` the Deleter reads `v` at ordinal 2 of a 2-element row, and secondary-index encoding panics with index out of range. A stored computed column ahead of a primary-key column shifts the primary-key datum in the same way.
medium 47/91 (51.6%)
valid_entries() uses a bare truthiness check (`if e`) but its docstring promises "the non-empty entries." This silently drops legitimate falsy-but-non-empty values too -- 0, 0.0, False, [], {} -- not just "" or None. Any caller passing counts, scores, or booleans loses valid entries with no error raised.
Backup code validation is case-sensitive due to the use of indexOf(). This causes validation to fail if a user enters uppercase hex characters, as backup codes should be case-insensitive for a better user experience.
Logic error: when externalCalendarId is provided, you're searching for a calendar where externalId === externalCalendarId, but this will always fail since you're looking for a calendar that matches itself. Should likely find by credentialId or use different logic.
The interface gains `createEvent(event, credentialId)` and Google selects its calendar by matching that credential, but the Office365 (and Lark) implementation still destructures `const [mainHostDestinationCalendar] = event.destinationCalendar ?? []` and builds the request path from element zero, ignoring the credential. `EventManager.createAllCalendarEvents` now loops once per host credential, so every iteration writes to the organizer's calendar id under a different member's token.
The diff converts the outer cancellation lookup from `find` to `filter` and loops over every calendar reference, but the recurring branch still resolves a single reference with `references.find((ref) => ref.type.includes('_calendar'))` and iterates only the organizer's credentials. For each remaining occurrence only the first reference is deleted and only with the organizer's credentials, so team members' calendar events survive the cancellation.
`sendAddGuestsEmails` takes no event-type metadata and unconditionally sends to the organizer, every team member and every attendee, while every other booking-lifecycle sender in the same file gates on the helpers that read `disableStandardEmails.all.host` and `.attendee`. The handler already loads the event type, so the metadata is in hand and simply not passed, and an organizer who disabled standard emails still has them sent.
The new immediateDelete branch of deleteScheduledEmailReminder cancels the scheduled email at SendGrid on the spot, and three new call sites use it (rescheduling in handleNewBooking, workflow and workflow-step deletion in workflows.tsx). Each such cancellation stays pending in SendGrid's scheduled_sends until the email's send time, up to 72h ahead, and SendGrid allows only 100 pending cancellations: the limit this PR's deferred, cron-driven cancellation exists to stay under. Under steady rescheduling the immediate cancellations fill it, after which cancellations are rejected (and only logged), both the immediate ones and the cron's deferred ones, so reminders for rescheduled and cancelled bookings are sent anyway.
The downsize method is defined twice. The second definition, which expects a single dimensions string parameter, overrides the first, which expected separate max_width and max_height parameters. This makes the original method unreachable and breaks existing code that calls it with separate width and height arguments.
Passing 80% as the dimensions can fail for animated GIFs when allow_animated_thumbnails is true, since the animated path uses gifsicle --resize-fit which expects WxH geometry, not a percentage; downsizing would then silently fail.
The new downsize loop tests `tempfile.size` and passes the same expression as the filesize argument to `Upload.create_for`, but the conversion ends in an image optimizer that atomically replaces the file. After the first pass the open Tempfile descriptor refers to an orphaned inode, so the reported size stops tracking the file on disk: the loop condition is frozen at the post-first-pass value and the upload is then rejected as too large by the validator even though the file has been shrunk well under the limit.
NoMethodError before_validation in EmbeddableHost
Because this migration inserts embeddable_hosts rows with raw SQL, any existing embeddable_hosts values that include http:// or /https:// or path segments won’t go through the EmbeddableHost model’s normalization, so the new host lookup (which compares only the bare host) may fail for migrated data. Consider ensuring that migrated hosts are normalized to the same format as newly created EmbeddableHost records so existing embedding configurations keep working.
The new plural-ID hydration branch in `_hydrateEmbedded` (added alongside the existing singular path) maps a list of ids through `_lookupSubType` and assigns the result unconditionally: `obj[self.pluralize(subType)] = hydrated || []`. `_lookupSubType` returns `undefined` for an id whose root collection or specific id isn't found; since Array.prototype.map always returns an array, `hydrated` is always truthy and the `|| []` fallback never fires, so the resulting array can contain literal `undefined` entries (e.g. [ModelObj, undefined, ModelObj]). This is the reverse of the existing singular path, which correctly guards with `if (hydrated)` before assigning.
poll_feed.rb calls `i.content.scrub` on every item, but SimpleRSS returns nil for `i.content` on plain RSS 2.0 feeds (body in description/content:encoded absent), so `nil.scrub` raises NoMethodError, aborting the whole un-retried hourly poll and importing nothing.
Statement IDs are built with `h := fnv.New128()`; the stdlib hash/fnv constructor heap-allocates a hash object on every statement, and the ID is constructed even when not required. On hot SQL paths this is a measurable allocation/throughput regression (the fix's microbenchmarks show kv95 +3.42%). The fix uses a lightweight value-type FNV and only builds the ID when needed. (Large-diff stress case: ~2.8k lines, 14 files.)
recordTransaction unconditionally records CommitLat via getCommitLatency() for both txnCommit and txnRollback, but sessionStartTransactionCommit/sessionEndTransactionCommit are only set in commitSQLTransaction and never reset between txns, so rolled-back transactions record a stale (prior commit) or zero commit latency into their CommitLat stats.
`resetAndMaybeDumpStats` copies and re-makes `a.stmts` but the diff's new per-fingerprint `a.txns` map is neither transferred to the copy nor cleared. Transaction statistics therefore survive every reset, are never handed to the reported-stats sink, and accumulate one entry per distinct transaction fingerprint for the lifetime of the node.
`remove_member` deletes the association with `group.users.delete(user_id)`, which for a has_many-through with no `:dependent` resolves to a raw `delete_all` and never instantiates the join model, so the `counter_cache` on GroupUser never decrements. The sibling add path uses `group.add(user)`, which does instantiate and increments, so `groups.user_count` drifts upward monotonically and is rendered to admins and returned by the group endpoint.
`ZUploadPrivateFileRequest` gains `elementId` as a required string with no `.optional()` and no default, and its single consumer returns 400 on parse failure before destructuring the field into the signed-URL path. The published contract is not updated: the OpenAPI reference still documents the endpoint as requiring only surveyId, fileName and fileType, and the diff does not touch it.
`isScopedPrivateUploadUrl` rejects anything that is not exactly the new eight-segment shape (`if (segments?.length !== 8) return false`), and `validateClientFileUploads` fails on that. Legacy private upload URLs are four segments, so a response created before the deploy can never be updated afterwards. The same diff's `parseStorageFileUrl` is deliberately tolerant, so the delete path stays backward compatible while the validate path does not.
Inconsistency: using name instead of options.Kind for metrics recording differs from other methods.
Calling s.search.TotalDocs() here may race with concurrent index creation: TotalDocs iterates b.cache without synchronization, and the event watcher goroutine started just above could trigger BuildIndex writes concurrently, potentially causing a concurrent map read/write panic.
`TestNewClaimInfoFromClaim` and `TestNewClaimInfoFromState` assert with an inverted condition: `if reflect.DeepEqual(result, test.expectedResult) { t.Errorf(...) }`. That reports a failure only when the result MATCHES the expectation, so the tests never validate the constructor and pass vacuously (and `expectedResult` is left nil). The fix inverts the check to `if !reflect.DeepEqual(...)`.
The claimInfo-cache tests seed their "item in cache" fixtures under the key `claimName + namespace`, but the cache itself keys entries on `namespace + "/" + claimName`. The mismatched key means the seeded entry is never found, so the `get`/`delete`/`contains` tests pass vacuously without exercising the real lookup. The fix keys the fixtures on `namespace + "/" + claimName` to match the cache.
The cacher delegator's `GetList` adds an unconditional `if errors.IsResourceExpired(err) { return c.storage.GetList(...) }` fallback to etcd. When the cache snapshot is nil the cacher returns `ResourceExpired`, so consistent paginated LISTs silently fall back to etcd instead of being served from cache, defeating the feature and adding etcd load. The fix gates that fallback behind the cache-snapshot feature flag.
Both group list endpoints drop the hoisted global permission check (`boolean canViewGlobal = groupsEvaluator.canView()`) and filter with a per-group `groupsEvaluator::canView`. Under fine-grained admin permissions v2 that per-group call falls through to a resource lookup and a full uncached policy evaluation, so one evaluation becomes one per group; the subgroup endpoint is worse because it fetches subgroups unbounded and paginates only after filtering.
In verifySafeHtml the prefix length `start` and suffix length `end` are computed independently with no `start+end <= value.length()` guard, so when the OWASP sanitizer balances mis-nested allowed tags (e.g. `<p><b>x</p>` → `<p><b>x</b></p>`) the overlapping prefix/suffix make `value.substring(start, value.length()-end)` have beginIndex > endIndex, throwing StringIndexOutOfBoundsException exactly on the illegal-HTML case it should report.
The client-credentials grant builds its token through `tokenManager.responseBuilder(...).generateAccessToken()` directly, bypassing the shared response path where the diff sets `Constants.GRANT_TYPE` on the client session context. `initToken` then reads that attribute, finds it null and substitutes the unknown marker, so every client-credentials token id encodes `na` rather than the shortcut the diff registers for this grant. Every other direct-responseBuilder path in the PR was updated; this one was missed.
`SourceUtils.findMatchingChild` iterates a folder's children and returns the first name match without excluding directories (no `isFolder()` / file-vs-folder check). A directory whose name equals the class name (e.g. a package dir `Test/` next to `Test.java`) is returned as the "source file", so go-to-source resolves to a folder instead of the file. The fix skips folders when matching.
The image-optimizer move to response-cache dropped the maxAge argument to sendResponse and hardcoded the cached-image header to `public, max-age=0, must-revalidate` instead of `max-age=${maxAge}`. The computed upstream/minimumCacheTTL maxAge is no longer propagated, so every optimized image returns max-age=0 and CDNs/browsers in front of a single instance stop caching, inflating origin load. (Large-diff stress case: ~3.6k lines, 15 files.)
The pages template sets `isIsrFallback` for an ungenerated path of a `fallback: true` route and clears it only for bots, minimal mode or an existing cache entry, never for on-demand revalidation. Base-server forced a blocking render when `isOnDemandRevalidate` was set. So `res.revalidate('/posts/new')` for a path not yet generated now returns the build-time fallback shell with its cache control deleted: nothing is stored, yet the response carries `x-nextjs-cache: REVALIDATED`, so the revalidate call reports success without generating the page.
The app-page template adds an early `if (isSSG && prerenderInfo?.fallback === false && !isPrerendered) throw new NoFallbackError()` that runs before draft mode or minimal mode is considered. The base-server check it replaces skipped preview/draft mode and minimal mode, and the sibling pages and app-route templates keep a `!isDraftMode` guard. A draft-mode request for a path of a `dynamicParams = false` app page that was not prerendered now returns 404 instead of rendering on demand, which breaks CMS preview of unpublished pages.
`OptimizedCursorPaginator.value_from_cursor` returns `cursor.value` raw, an int or float, where `DateTimePaginator` converts it back to an aware datetime. `BasePaginator.build_queryset` splices that value straight into raw SQL, so with `order_by='-datetime'` Postgres is asked to compare a timestamptz against a bigint and raises `operator does not exist`.
OptimizedCursorPaginator negative-offset branch slices QuerySet with a negative start index
BasePaginator negative-offset branch slices QuerySet with a negative start index
The new `upsampled_count` SnQL function in `DiscoverDatasetConfig` (datasets/discover.py) is `toInt64(sum(sample_weight))` with no fallback for a missing weight. Snuba stores `sample_weight` as Nullable(Float64) and writes NULL for any error event that carried no client sample rate, and `sum` skips NULLs. Once events-stats rewrites `count()` to `upsampled_count() as count` for an allowlisted project set, every unweighted event counts as 0 instead of 1, so error charts undercount, and a bucket holding only unweighted events returns NULL instead of its event count.
chSQLQuery.renderVars substitutes variable values into the raw ClickHouse query string via strings.Replace BEFORE parsing that string as a Go text/template (tmpl.Parse(query) / tmpl.Execute). If a variable's own VALUE contains the Go template delimiters {{/}}, the substituted text is then re-interpreted as a live template action in the second stage -- e.g. a variable value of "{{.SIGNOZ_START_TIME}}" gets replaced with the numeric start timestamp rather than being treated as literal text, silently changing the rendered query; a malformed template fragment (e.g. "{{.") causes template.Parse to fail, surfacing as an opaque HTTP 500.
parseFieldKeyRequest renames the field-key search parameter from ?name to ?searchText (r.URL.Query().Get("name") -> r.URL.Query().Get("searchText")). parseFieldValueRequest calls parseFieldKeyRequest internally (now reading ?searchText) and separately reads ?name for a different purpose (keySelector.Name, overriding what the key-request set). Any existing caller using GET /api/v1/fields?name=service_name to filter the field-key list gets back all keys instead of a filtered set -- the ?name parameter is simply ignored for that endpoint, a breaking API change with no version bump.
Every single mutation in the app does a read-modify-write on the same singleton document: read the current count, increment it, write it back. This is a textbook OCC (Optimistic Concurrency Control) hotspot. Under any concurrent load, all mutations contend on this one document, causing retries and potential failures. In Convex, when two mutations read and write to the same document concurrently, one will be retried. A global singleton that every mutation touches is the worst possible write contention pattern. The correct approach would be sharded counters, an aggregate component, or simply not tracking this metric at the mutation level.
The new image-set loader offers a "Pad" resize option whose branch is identical to "Stretch": it calls the same full resize to the target width and height, with no aspect-preserving thumbnail and no border fill. A user who loads a folder of differently sized images and picks "Pad" to keep aspect ratio gets every image whose size differs from the first one non-uniformly squashed, silently corrupting the training data, with nothing reporting that the chosen option behaved the same as "Stretch".
The textarea XML schema is changed to declare the placeholder property as `placeholder_text`, but the textarea XML parser, which the change does not touch, still matches only the attribute name `placeholder`. XML written against the updated schema, such as `<lv_textarea placeholder_text="Type here"/>`, matches no branch in the parser's attribute chain, so `lv_textarea_set_placeholder_text` is never called. The attribute loop has no unknown-attribute warning, so the placeholder is dropped silently.
`grid_update` gains an early return when the grid calculation fails, but the calculation has already allocated its row arrays by then and the early return skips the free routine. A grid container that has a row descriptor but no column descriptor, on itself or its parent, gets `c->y` and `c->h` allocated in the row pass and then fails the column pass, leaking both arrays on every layout refresh. Calling the existing free routine at that point is not by itself a safe fix, because the struct is not zeroed on every failure path.
The filename language guesser reuses one `checked_tag` latch for both the hearing-impaired (`sdh`/`hi`/`cc`) and the newly added `forced` suffix, so only the last dot-separated suffix is ever tested as a tag. For a subtitle named `movie.en.sdh.forced.srt` the parser strips `forced`, sets the latch, and then reads `sdh` as the language, returning language "sdh" with the hearing-impaired flag unset. With the suffixes the other way round, `movie.en.forced.sdh.srt`, the six-letter `forced` fails the primary-subtag length check, so no language is found and the forced flag is lost. The wrong language reaches real tracks through subtitle autoload and sub-reload.
The rewritten reply builder uses one array for two incompatible purposes: a depth-indexed slot array written by index, and a LIFO stash for RESP3 map keys pushed and popped. When a map key is itself an aggregate, the push lands at the same index the slot write uses and the key's children grow the array, so the following value pops the key's last child instead of the key. The map is returned with a wrong key and no error is raised.
low 11/32 (34.4%)
Hardcoding maxSizeKB = 10 * 1024 ignores Discourse.SiteSettings['max_' + type + '_size_kb'], so the client-side limit can diverge from server-side and per-type settings (also applies to the 413 handler below).
The update and destroy methods in Admin::EmbeddableHostsController do not validate the existence of the EmbeddableHost record retrieved by ID. If EmbeddableHost.where(id: params[:id]).first returns nil (i.e., the host does not exist), attempting to call methods on the nil object (e.g., save_host or destroy) will result in a NoMethodError.
record_for_host compares lower(host) = ? but does not normalize the parameter’s case, so mixed‑case referer hosts may fail to match even though comparison intends to be case‑insensitive.
The new `EmbeddableHost` model's format validation explicitly accepts a port (`(:[0-9]{1,5})?`), and `before_validation` strips only the scheme and path, so a host entered as `http://example.com:3000` or `example.com:3000` is stored as `example.com:3000`. `record_for_host` compares the port-less `URI#host` of the referer against that stored value, so it can never match, and embedding from that site is silently refused although the admin UI accepted the host.
The postMessage origin check uses reversed substring matching (`discourseUrl.indexOf(e.origin) === -1`), accepting any origin that is a substring of the configured Discourse URL rather than requiring an exact origin match; impact is limited to letting a non-Discourse frame resize the embed iframe.
In the next action, capping the next offset at user_count can produce an empty page (e.g., total equal to limit results in offset == total, showing 2/2 with no members). This can cause confusing UX on the last page.
The test comment says the cached permissions 'allow access', but the map stores false for dashboards:uid:dash1, so checkPermission will still treat this scope as not allowed.
The context is being created with d.Log instead of the log variable that was initialized with additional context values (name, kind, method). This means those values won't be propagated to the logging context.
Bug: calling recordLegacyDuration when storage operation fails should be recordStorageDuration.
Cleanup reference uses incorrect alias - should be 'idp-alias-' + i instead of 'alias'.
Dead code exists where ASN1Encoder instances are created and written to, but their results are immediately discarded. The actual encoding is performed by new ASN1Encoder instances created in the subsequent return statement, rendering the earlier operations useless.
Wrong parameter in null check (grantType vs. rawTokenId)
In isAccessTokenId, the substring for the grant shortcut and the equality check look inverted: the grant shortcut occupies indices 4–5 (substring(4,6)), and a match should return true (combined with UUID check), not false.
The app-route template's outer catch now calls `routeModule.onRequestError(req, err, {...})` without the fourth `routerServerContext` argument that every other call site in this diff passes. `RouteModule.onRequestError` therefore falls back to a bare `console.error(err)` instead of `routerServerContext.logErrorWithOriginalStack`, so a server started with `quiet: true` now prints route-handler errors, a normal server loses the standard error prefix, and in dev the original-stack logger is skipped.
The app-page template's responseGenerator copies base-server's static-shell-debugging short-circuit, which returns a cache entry of `kind: CachedRouteKind.PAGES`. The template's own handleResponse then throws "Invariant app-page handler received invalid cache entry PAGES" for any kind other than APP_PAGE. Base-server served that entry through its generic branch as an empty HTML response, so a static-shell debugging request now fails with the invariant error.
The span bar position is computed with a CSS clamp: `left: clamp(0%, ${toPercent(bounds.left || 0)}, calc(100% - 1px))`. clamp floors the value at 0%, but when the view is zoomed via the minimap a span that starts before the visible window has a legitimately negative left; flooring it to 0% mis-positions the bar. The fix uses min(...) (no lower bound) so negative offsets render correctly.
Shared mutable default in dataclass timestamp
Breaking out of the loop when the deadline has elapsed can skip terminating remaining flusher processes, potentially leaving them running after shutdown; consider ensuring termination is attempted even if the deadline is exceeded.
With upsampling applied, events-stats sends the literal column `upsampled_count() as count` to the query builder. When the client also sets transformAliasToInputFormat=1, the builder's process_results renames the result key to that full input string, while the serializer looks up `count()` (resolve_axis_column returns the raw y-axis). `r.get(column, 0)` then finds nothing, so every bucket of the time series comes back as 0.
The new checklist mutations write no `activityLog` entry, while every other task-mutating operation does: `create`, `update` and `remove` in convex/tasks.ts each call `ctx.runMutation(internal.activity.log, ...)`. A task's checklist can therefore be changed with no record, leaving the activity history incomplete for that class of edit.
`addItem` takes `text: v.string()` and pushes it unchanged, so a blank or whitespace-only item is stored. The only guard is client-side, `if (!newChecklistItem.trim()) return` in TaskDetail.tsx, and a Convex mutation is a public API reachable without that component.

By diff size — compare every bot

Falls behind on large diffs

The gap moves -24 pts from small to large, so it drops off more than the other bots do as PRs grow.

Diff sizeCasesBugs caughtCoverageOther bots, same PRsvs othersFalse-alarms
small ≤100 lines 54 49/64 81% 88% -7 pts 1%
medium 101–500 lines 40 46/74 62% 74% -13 pts 4%
large >500 lines 33 33/98 32% 63% -31 pts 8%

Every bot catches less as PRs grow, so a falling coverage number is expected. The question is whether this bot falls more or less than the others. vs others is its coverage minus what the other bots caught on the exact same PRs. The label compares that gap on small PRs with the gap on large ones; it takes a 10-point move to count. Coverage is severity-weighted: a critical bug counts 8×, a low one 1×.

Review time

Median 2.7 min and 90th percentile 5.7 min over 127 reviews; its first comment came after 0.9 min (median).

Diff sizeReviewsMedian90th percentile
small ≤100 lines541.6 min3.8 min
medium 101–500 lines403.6 min5.6 min
large >500 lines334.5 min6.7 min

Timed from the pull request opening, or the comment that asked for a re-review, to the bot's last comment, so it includes the time the review waited in the vendor's queue. See methodology.

Trajectory — coverage over time

RunCoverageValidityCases
2026-06-1277.6%91.5%21
2026-06-2162.9%91.5%97
2026-10-0853.7%94.4%118
2026-10-1077.8%100.0%9
2026-10-25100.0%100.0%8

Cases reviewed

Authored · Tier 1 · found 36/39 · 36 cases

CaseFoundFindingsFalse-alarms
A new required TRACKER_GEOCODER_URL setting is not added to the Helm chart, so every pod fails at startup 1/1 1 0
A new required TRACKER_GEOCODER_URL setting is not added to the Helm chart, so every pod fails at startup 1/1 1 0
Binary-sink migration missed an unchanged Serializer implementer (CsvSerializer still returns str) 1/1 1 0
Binding the tenant scope with `let _ =` drops the guard at once, so the digest reads every tenant's rows 1/1 1 0
Day-bucketing the keyset filter in the session timezone diverges from the UTC-pinned cursor and empties page 2 1/1 1 0
Environment scoping added to create/update but not the sibling delete leaves a cross-env IDOR 1/2 2 0
Filtering empty entries silently misaligns audit's positional entry/timestamp pairing 1/2 1 0
Handlers are now built once per context instead of per event, so the PayoutFees the fee schedule keeps for each payout.paid handler, which charges each seller once, stops charging the payout fee after a seller's first payout 1/1 1 0
Handlers are now built once per context instead of per event, so the PayoutFees the fee schedule keeps for each payout.paid handler, which charges each seller once, stops charging the payout fee after a seller's first payout 1/1 1 0
Lowercasing tags silently breaks the case-sensitive admin check in access.py 1/1 1 0
Moving the Server Action redirect into the render commit drops it on the unchanged non-React result path 2/2 2 0
Narrowing a shared visibility gate for one control silently hides two unrelated controls 0/1 0 0
Rejecting a zero throttle interval silently stops an unthrottled heartbeat that must always fire 1/1 1 0
Reordering Job's fields silently re-ranks the unchanged scheduler's heap by name instead of priority 1/1 1 0
Reusing a scratch buffer for end keys corrupts every recorded span via the retaining writer 1/1 1 0
Routing Amex to the legacy gateway breaks payments via an unchanged capability the diff can't see 1/1 1 0
Sorting the roster silently misaligns payroll's positional name/amount pairing 1/1 1 0
Stripping the trailing slash silently malforms URLs built by the unchanged helper 1/1 1 0
Switching encode() to chunks_exact silently discards the partial final frame of every batch 1/1 1 0
Switching flusher workers to the spawn context silently disables the reaper's isinstance-gated kill 1/1 1 0
The cached shipment payload changes shape without bumping CACHE_VERSION, so old entries are read as current 1/1 1 0
The cached shipment payload changes shape without bumping CACHE_VERSION, so old entries are read as current 1/1 1 0
The location record gains a field but the TypeScript client decoder keeps the old record layout 1/1 2 0
The location record gains a field but the TypeScript client decoder keeps the old record layout 1/1 1 0
check now sees each family's canonical values, and for an EDI line canonical() sets the quantity in units through units(), so Pinecrest's cap on the quantity as ordered rejects every case line over 150 units 1/1 1 0
check now sees each family's canonical values, and for an EDI line canonical() sets the quantity in units through units(), so Pinecrest's cap on the quantity as ordered rejects every case line over 150 units 1/1 1 0
load_flags() returns None for empty config, breaking the membership check in gate.py 1/1 1 0
position_of() not-found sentinel changed None -> -1, breaking router's `is None` guard 1/1 1 0
transform() returning nothing now drops the event, and an unchanged handler's transform still returns nothing, dropping every dispute 1/1 1 0
transform() returning nothing now drops the event, and an unchanged handler's transform still returns nothing, dropping every dispute 1/1 1 0
transform() returning nothing now drops the event, and the dispute handler's transform returns noteMissing(), which returns nothing, dropping every dispute 1/1 1 0
transform() returning nothing now drops the event, and the dispute handler's transform returns noteMissing(), which returns nothing, dropping every dispute 1/1 1 0
validate() now skips on a falsy return, and an unchanged handler's validate still returns None, dropping every refund 1/1 1 0
validate() now skips on a falsy return, and an unchanged handler's validate still returns None, dropping every refund 1/1 1 0
validate() now skips on a falsy return, and the refund handler's validate returns note_missing(), which returns the optional fields it found missing: an empty list for every refund that has a reason 1/1 1 0
validate() now skips on a falsy return, and the refund handler's validate returns note_missing(), which returns the optional fields it found missing: an empty list for every refund that has a reason 1/1 1 0

Cal.com · Tier 2 · found 20/36 · 11 cases

CaseFoundFindingsFalse-alarms
Add guest management functionality to existing bookings 4/5 9 0
Advanced date override handling and timezone compatibility improvements 4/4 4 0
Async import of the appStore packages 1/1 3 0
Comprehensive workflow reminder management for booking lifecycle events 2/3 3 0
OAuth credential sync and app integration enhancements 6/7 8 0
SMS workflow reminder retry count tracking 1/3 2 0
feat: 2fa backup codes 1/3 5 0
feat: `Troubleshooter` atom 0/1 0 0
feat: add calendar cache status and actions (#22532) 1/1 8 0
fix: handle collective multiple host on destinationCalendar 0/7 0 0
fix: instant booking location lookup 0/1 2 0

CockroachDB · Tier 2 · found 1/11 · 5 cases

CaseFoundFindingsFalse-alarms
Backup manifest EndKey stored without Clone is corrupted by a caller's scratch-buffer reuse 1/3 4 0
Crud writer feeds tombstone updates a row without stored computed columns, panicking the Deleter 0/1 6 1
Per-statement fnv.New128() allocation is a hot-path throughput regression 0/4 0 0
Tombstone updater re-leases its descriptor on every call and reports failed updates as success 0/2 0 0
Treating min_checkpoint_frequency=0 as 'disabled' stalls the changefeed highwater 0/1 2 0

ComfyUI · Tier 2 · found 0/1 · 1 cases

CaseFoundFindingsFalse-alarms
Add LoRA trainer nodes and image-set loaders 0/1 10 0

Deno · Tier 2 · found 1/1 · 1 cases

CaseFoundFindingsFalse-alarms
fix(npm): handle deno run/install of npm package with only directories.bin 1/1 3 0

Discourse · Tier 2 · found 4/23 · 7 cases

CaseFoundFindingsFalse-alarms
Add comprehensive email validation for blocked users 1/1 3 0
Enhance embed URL handling and validation system 0/5 1 0
FEATURE: Can edit category/host relationships for embedding 0/8 0 0
FEATURE: automatically downsize large images 0/4 0 0
FEATURE: per-topic unsubscribe option in emails 2/2 6 2
FIX: proper handling of group memberships 0/2 0 0
Optimize header layout performance with flexbox mixins 1/1 1 0

Django · Tier 2 · found 1/2 · 1 cases

CaseFoundFindingsFalse-alarms
Fixed #36273 -- Moved Index system checks from Model to Index.check(). 1/2 2 0

Formbricks · Tier 2 · found 0/4 · 2 cases

CaseFoundFindingsFalse-alarms
Add response-pipeline webhook delivery job 0/1 0 0
Storage auth session path uses a role-blind access check, letting billing-role users escalate 0/3 0 0

Grafana · Tier 2 · found 13/19 · 9 cases

CaseFoundFindingsFalse-alarms
Advanced SQL Analytics Framework 2/2 2 0
Anonymous: Add configurable device limit 2/2 3 0
AuthZService: improve authz caching 1/2 2 0
DashboardDS: Fix Mixed panels not updating on time-range change with stale upstreams 1/1 1 0
Database Performance Optimizations 2/2 5 0
Dual Storage Architecture 0/4 0 0
Frontend Asset Optimization 1/1 2 0
Notification Rule Processing Engine 3/3 4 0
Unified Storage Performance Optimizations 1/2 2 0

Keycloak · Tier 2 · found 7/14 · 9 cases

CaseFoundFindingsFalse-alarms
Add AuthzClientCryptoProvider for authorization client cryptographic operations 1/2 5 2
Add Client resource type and scopes to authorization schema 1/1 6 2
Add Groups resource type and scopes to authorization schema 2/3 6 0
Add HTML sanitizer for translated message resources 0/1 6 1
Add caching support for IdentityProviderStorageProvider.getForLogin operations 0/1 0 0
Add rolling-updates feature flag and compatibility framework trap 1 0
Fix concurrent group access to prevent NullPointerException 1/1 3 0
Fixing Re-authentication with passkeys 2/2 3 0
Implement access token context encoding framework 0/3 0 0

Kubernetes · Tier 2 · found 2/8 · 4 cases

CaseFoundFindingsFalse-alarms
Reduce cache locking duration when the DaemonSet controller fetches pods 0/1 0 0
Serve LISTs with exact ResourceVersion and continuations from the cache 2/3 3 0
Trim managedFields in the controller-manager and scheduler informer transforms 0/1 1 0
kubelet DRA: update claimInfo cache locking and checkpoint semantics 0/3 0 0

LVGL · Tier 2 · found 1/3 · 1 cases

CaseFoundFindingsFalse-alarms
xml: sync the widget schemas with the runtime parsers 1/3 14 0

mpv · Tier 2 · found 0/1 · 1 cases

CaseFoundFindingsFalse-alarms
player: detect forced subtitle tracks from the filename 0/1 2 0

n8n · Tier 2 · found 1/1 · 1 cases

CaseFoundFindingsFalse-alarms
fix(editor): Load credentials when opening node credential picker 1/1 3 0

NetBeans · Tier 2 · found 1/2 · 2 cases

CaseFoundFindingsFalse-alarms
Extract the source file name from the .class and use it to locate the source 0/1 5 0
LSP: do not compute text edits in source actions on resolve 1/1 2 0

Next.js · Tier 2 · found 5/15 · 4 cases

CaseFoundFindingsFalse-alarms
Image optimizer hardcodes max-age=0, discarding the upstream cache TTL 3/4 5 0
Passing nextConfig: undefined also disables basePath stripping, corrupting router.query 0/1 1 1
Server Action external redirect is dropped when invoked outside a React scope 0/1 2 1
Wrapping the data response in a Buffer misclassifies it as dynamic, dropping Content-Length and ETag 2/9 7 2

Novu · Tier 2 · found 0/1 · 1 cases

CaseFoundFindingsFalse-alarms
Environment scoping added to create/update integration routes but not the sibling mutations 0/1 0 0

OpenCV · Tier 2 · found 1/1 · 1 cases

CaseFoundFindingsFalse-alarms
videoio: add IStreamReader support to the Java bindings 1/1 3 0

PostHog · Tier 2 · found 2/4 · 6 cases

CaseFoundFindingsFalse-alarms
Email-queue routing parks workflow waits on a queue the subscription matcher never searches 1/1 4 0
Hardcoded queue_name='hogflow' filter never finds email-routed parked waits trap 5 0
Narrowing a shared visibility flag hides sync-method/field/primary-key columns for non-SQL sources 0/1 3 0
Raw query uses the HogQL table alias 'logs' instead of the physical 'logs_distributed' 0/1 1 0
Timezone-unpinned toStartOfDay vs UTC-pinned date constants empties keyset page 2 trap 4 0
feat(sig): custom agents 1/1 3 0

Redis Client · Tier 2 · found 1/2 · 1 cases

CaseFoundFindingsFalse-alarms
Implement Write Barriers for HiredisConnection 1/2 1 0

Sentry · Tier 2 · found 12/23 · 10 cases

CaseFoundFindingsFalse-alarms
Enhanced Pagination Performance for High-Volume Audit Logs 3/4 3 0
GitHub OAuth Security Enhancement 2/2 4 0
GitLab integration search returns full project paths 2/2 5 1
Optimize spans buffer insertion with eviction during insert 1/3 4 0
Span Buffer Multiprocess Enhancement with Health Monitoring 0/2 0 0
Span tree minimap and secondary panel 0/2 0 0
feat(ecosystem): Implement cross-system issue synchronization 0/1 0 0
feat(upsampling) - Support upsampled error count with performance optimizations 2/4 5 0
feat(uptime): Add ability to use queues to manage parallelism 2/2 5 1
feat(workflow_engine): Add in hook for producing occurrences from the stateful detector 0/1 0 0

SigNoz · Tier 2 · found 8/11 · 2 cases

CaseFoundFindingsFalse-alarms
chore: recognize variable in expression 6/9 11 1
fix: do not sort in descending locally if the other is explicitly specified 2/2 3 0

TaskFlow (Convex) · Tier 2 · found 10/13 · 10 cases

CaseFoundFindingsFalse-alarms
.collect() Just to Count (TaskFlow PR #6) 1/1 2 0
.filter() vs Index (TaskFlow PR #2) 1/1 1 0
Authorization Bypass (TaskFlow PR #10) 2/2 2 0
Exposed Internals (TaskFlow PR #4) 1/1 2 0
Missing Aggregate Update (TaskFlow PR #8) 1/1 1 0
Missing Auth Check (TaskFlow PR #3) 1/1 4 0
Nested Lookups (TaskFlow PR #1) trap 3 1
OCC Conflict on Hot Path (TaskFlow PR #9) 0/1 0 0
Unbounded .collect() (TaskFlow PR #5) 1/1 1 0
Unbounded Array in Document (TaskFlow PR #7) 2/4 3 0

Tauri · Tier 2 · found 1/1 · 1 cases

CaseFoundFindingsFalse-alarms
fix(core): Correctly detect Android Tauri configuration file, closes #7785 1/1 4 0