Skip to content

fix(iam): check CloudWatch Logs requests on the resources they name, from the generated table - #9088

Merged
pgermosen merged 1 commit into
mainfrom
fix/iam-logs-request-resources
Nov 20, 2026
Merged

pgermosen merged 1 commit into
mainfrom
fix/iam-logs-request-resources

Conversation

@pgermosen

@pgermosen pgermosen commented Nov 20, 2026 •

Copy link
Copy Markdown
Member

Summary

CloudWatch Logs was one of the namespaces ResourceArnBuilder built by hand, and the last one the generator read only in part. The builder made a group ARN (with a trailing :*) for CreateLogGroup, DeleteLogGroup, PutRetentionPolicy and DeleteRetentionPolicy, a stream ARN for CreateLogStream and DeleteLogStream, and resolved the tag operations' resourceArn itself. Every other Logs operation was checked on *, PutLogEvents, FilterLogEvents, metric and subscription filters and Insights queries among them. Only the vended-log delivery operations and PutDestination came from iam-request-resources.json, through READ_IN_HAND_BUILT. Logs now comes from the generated table whole, as every namespace is meant to.

  • Logs is read from the table. logs moves from HAND_BUILT to NAMESPACES, and the generator's existing rules give each of its 118 operations the log group, log stream, destination, lookup table, anomaly detector, scheduled query or delivery resource its request names, from botocore and the Service Reference. Of the 53 operations Floci serves, about 25 that were checked on * are now checked on their group, stream or destination, so a policy scoped to one group or stream now means something for them, as on AWS; a policy on * passes as before. The ARNs take the request's partition. ResourceArnBuilder.buildLogResources and IamEnforcementFilter's Logs case are gone.
  • READ_IN_HAND_BUILT is gone. Its only entries were Logs' 14 operations, so the list, reads()'s clause for it, its checks in _check_overrides and verify_against, the docstring paragraph and its two tests go with it. A hand-built namespace now reads only what MEASURED gives (DynamoDB's ListTables).
  • Log group ARNs follow the Service Reference's format. The table checks a group operation on log-group:<name>, without the trailing :* the builder added. IamPolicyEvaluator already matches a policy naming the group with or without :* for CreateLogGroup, DeleteLogGroup, PutRetentionPolicy, DeleteRetentionPolicy and TagLogGroup, so policies written either way keep working for those. The tagged CreateLogGroup check, which takes either logs:TagResource or logs:TagLogGroup, now reads the table's bare group ARN for both instead of cutting :* off the builder's.
  • Logs only looks up. CloudWatchLogsStoredResourceArns answers storedTags for a log group (read in place by the name its ARN gives, a trailing :* dropped as the tag handlers drop it, in the ARN's Region), a destination and a delivery source, delivery destination or delivery, all in the request's account. A resource Floci does not hold has none; any other lookup failure is thrown, so it cannot pass for a resource without tags. IamConditionContextResolver's Logs branch keeps only what no generated source gives, the request tags of a tagged CreateLogGroup, TagResource and UntagResource, and its two Logs service dependencies go. TagLogGroup and UntagLogGroup changed the group's tag map in place without a lock; they now give the group a new map under the lock creating and deleting a group take, so a tag call racing a delete cannot put the group back, and its tags field is volatile.
  • Only this namespace. The table keeps every other namespace's entries as they were, and make iam-request-resources-check passes on it.

Where the generated reading differs from the builder's, stated plainly:

  • A stream call (CreateLogStream, DeleteLogStream) no longer carries its log group's tags as aws:ResourceTag/<key>. Floci holds no tags on a stream, and nothing AWS publishes gives a stream its group's tags, so a stream ARN has none. A condition on the group's tags no longer matches a stream call.
  • A tag call naming its group by a plain name where AWS takes an ARN (a Floci compatibility form the handlers still accept) names nothing the table reads, so it is checked on *. A group ARN given with a trailing :* is checked as written.
  • The group operations the Service Reference gives the log-group type, FilterLogEvents, DescribeLogStreams, the metric and subscription filter calls and StartQuery among them, are checked on the group's ARN as that type's format gives it, log-group:<name>. A policy naming the group as log-group:<name>:* does not match them, as it did not before, when they were checked on *; one naming the bare group ARN now matches them, an Allow and a Deny alike. IamPolicyEvaluator matches both forms only for the five group-management actions above. A policy on * matches them as before, and one on log-group:* now matches them too.
  • GetLogEvents, FilterLogEvents and the other operations that also take logGroupIdentifier are checked on the group their logGroupName names. A request naming the group only by logGroupIdentifier is checked on *, as all of them were before.

Type of change

  • Bug fix (fix:)
  • New feature (feat:)
  • Breaking change (feat!: or fix!:)
  • Docs / chore

AWS Compatibility

The Service Authorization Reference gives CloudWatch Logs the types log-group (arn:${Partition}:logs:${Region}:${Account}:log-group:${LogGroupName}), log-stream (...:log-group:${LogGroupName}:log-stream:${LogStreamName}), destination, delivery-source, delivery-destination, delivery, anomaly-detector, lookup-table and scheduled-query, each with aws:ResourceTag/${TagKey}, and lists the type each action acts on: PutLogEvents and GetLogEvents on log-stream; FilterLogEvents, DescribeLogStreams, PutMetricFilter, PutSubscriptionFilter and StartQuery on log-group, among others. The CloudWatch Logs guide's access control overview gives a log group's ARN with and without the trailing :*.

Checklist

  • ./mvnw test passes locally (ran the generator's tests, the request resource reader, builder, filter and condition context tests, every Logs test class that needs no Docker, the CloudFormation and Lambda classes that use Logs, the Logs IAM integration test classes, and the IAM enforcement classes that check resource-tag conditions, not the whole suite)
  • New or updated integration test added
  • Commit messages follow Conventional Commits
  • I have no more than 2 open, non-draft pull requests and no more than 4 open pull requests in total (drafts included) in this repository (maintainers and dependency bots are exempt).

@pgermosen pgermosen added bug Something isn't working cloudwatch Amazon CloudWatch (Logs & Metrics) iam AWS Identity and Access Management (IAM) labels Nov 20, 2026
@qodo-code-review

qodo-code-review Bot commented Nov 20, 2026 •

Copy link
Copy Markdown

PR Summary by Qodo

Check CloudWatch Logs IAM requests against generated resource ARNs

🐞 Bug fix 🧪 Tests 📝 Documentation 🕐 20-40 Minutes

Grey Divider

AI Description

• Check CloudWatch Logs operations against named groups, streams, destinations, and deliveries
 instead of wildcard resources.
• Use generated request-resource mappings and stored tags while retaining legacy log-group policy
 compatibility.
• Expand authorization tests and documentation for scoped access, tagging, and resource-tag
 conditions.
Merge Risk 🟡 Medium

Blast radius 🔴 High 💥 3 capabilities

  • 3 affected capabilities span independent functional scopes: cloudwatch_logs_iam_authorization, cloudwatch_logs_tag_management.
  • Resource-tag conditions participate in the same end-to-end Logs authorization decision as resource ARN construction.
  • The affected outcome is access to log data under tag-based policies, not a separate storage or deployment feature.
  • Tagging, retention, filter, and delivery-management authorization remain management outcomes within the same bounded Logs/IAM integration.
  • Tag lookup is a policy-input hop for those operations, not an independent functional scope.
  • This is the bounded group-tag management behavior that persists and reads tag state.
  • It is distinct from IAM authorization itself because the changed lock and replacement-map protocol governs the state transition consumed by tag APIs and authorization.
Behavioral complexity 🔴 High 🧩 Concurrent ordering, Coordinated invariants

  • Before, tag methods mutated the existing map and wrote the group without the new shared lock.
  • After, tag and untag copy the current map, replace it, and coordinate with group creation/deletion under metricFilterStore; LogGroup.tags is volatile for cross-thread publication.
  • The new correctness conditions are atomicity of the tag snapshot, no resurrection of a group deleted concurrently, preservation of concurrent updates, and visibility of a complete map to authorization reads.
  • These are newly coordinated state transitions rather than routine use of an existing collection.
Potential damage 🔴 High 🩹 Confidentiality

  • If a tag-based deny or allow is evaluated with the wrong group's tags or with empty tags, a principal may read log data outside the intended tag boundary.
  • Reverting code restores future decisions; previously disclosed logs cannot be recalled.
  • The source supports local account/Region filtering and explicit empty-tag behavior, but a mismatch between generated resource kind and handler semantics remains a plausible fault class.
  • Future access is recoverable by rollback or policy correction; prior disclosure is not automatically reversible.
Assessed commit 51e04ce
Diagram

graph TD
  Request["Logs request"] --> Filter["IAM filter"] --> Builder["Resource builder"] --> Table["Generated mappings"]
  Filter --> Resolver["Condition resolver"] --> Stored["Stored ARN lookup"] --> Storage["Logs storage"]
  Filter --> Evaluator["Policy evaluator"]
Loading
High-Level Assessment

Using the existing generated table is preferable to extending the hand-built Logs builder: it provides consistent coverage of AWS resource types without maintaining a second operation map. The PR retains service-specific code only for stored-resource lookups and request-tag conditions.

Files changed (18) +407 / -400

Enhancement (1) +60 / -4
CloudWatchLogsStoredResourceArns.javaResolve stored tags for Logs resource ARNs +60/-4

Resolve stored tags for Logs resource ARNs

• Adds tag lookups for local log groups, destinations, and delivery resources. Rejects other-account or unsupported ARN targets, treats missing resources as untagged, and propagates unexpected lookup errors.

src/main/java/io/floci/aws/services/cloudwatch/logs/CloudWatchLogsStoredResourceArns.java

Bug fix (4) +137 / -19
IamEnforcementFilter.javaRoute Logs targets through generated mappings +9/-13

Route Logs targets through generated mappings

• Removes the Logs-specific target-resource branch. Tagged group creation now checks both alternative tagging permissions against the table's bare group ARN.

src/main/java/io/floci/aws/core/common/IamEnforcementFilter.java

CloudWatchLogsService.javaProvide account-scoped group tags and whole-map tag writes +22/-4

Provide account-scoped group tags and whole-map tag writes

• Adds a stored-group tag lookup by account, region, and exact name. Tag and untag calls replace the group's tag map under synchronized methods rather than mutating it in place.

src/main/java/io/floci/aws/services/cloudwatch/logs/CloudWatchLogsService.java

LogGroup.javaPublish replaced log-group tag maps safely +1/-1

Publish replaced log-group tag maps safely

• Marks the tag-map reference volatile so readers can observe whole maps installed by tag mutations.

src/main/java/io/floci/aws/services/cloudwatch/logs/model/LogGroup.java

iam-request-resources.jsonAdd generated mappings for CloudWatch Logs operations +105/-1

Add generated mappings for CloudWatch Logs operations

• Removes Logs from the hand-built namespace list and adds mappings for its previously excluded operations. Entries identify request-named groups, streams, destinations, and other Logs resource types.

src/main/resources/aws/iam-request-resources.json

Refactor (3) +27 / -151
IamConditionContextResolver.javaLimit Logs-specific condition handling to request tags +17/-75

Limit Logs-specific condition handling to request tags

• Removes direct Logs service tag lookups and their injected dependencies. Retains request-tag and tag-key extraction for group creation and ARN tagging calls.

src/main/java/io/floci/aws/core/common/IamConditionContextResolver.java

ResourceArnBuilder.javaRemove hand-built CloudWatch Logs targets +0/-40

Remove hand-built CloudWatch Logs targets

• Deletes the Logs operation-specific ARN builder, including its wildcard fallback and direct tagging-target resolution.

src/main/java/io/floci/aws/services/iam/ResourceArnBuilder.java

regen_iam_request_resources.pyGenerate the complete Logs namespace +10/-36

Generate the complete Logs namespace

• Moves Logs into fully generated namespaces and removes the partial hand-built read override and its validation paths. Hand-built namespaces now read only measured exceptions.

tools/aws/regen_iam_request_resources.py

Tests (8) +152 / -200
IamConditionContextResolverTest.javaTest Logs request-tag condition extraction +20/-51

Test Logs request-tag condition extraction

• Replaces direct service-tag lookup tests with coverage of create, tag, and untag request conditions. Adjusts resolver construction after removing Logs service dependencies.

src/test/java/io/floci/aws/core/common/IamConditionContextResolverTest.java

RequestResourceMembersTest.javaAssert Logs is no longer hand-built +4/-12

Assert Logs is no longer hand-built

• Updates namespace assertions so DynamoDB's measured operation is the only table entry retained within a hand-built namespace.

src/test/java/io/floci/aws/core/common/RequestResourceMembersTest.java

DynamoDbFacadeTest.javaAdapt IAM resolver test construction +1/-1

Adapt IAM resolver test construction

• Removes the obsolete Logs dependency arguments from the resolver fixture.

src/test/java/io/floci/aws/services/dynamodb/backend/DynamoDbFacadeTest.java

LogsArnTagAuthorizationIntegrationTest.javaTest authorization of plain-name tag targets +8/-1

Test authorization of plain-name tag targets

• Checks that a historical plain-name target requires wildcard authorization because the generated table reads ARN-valued targets, while the handler still accepts the name.

src/test/java/io/floci/aws/services/iam/LogsArnTagAuthorizationIntegrationTest.java

LogsStreamAuthorizationIntegrationTest.javaExercise scoped Logs group and stream permissions +63/-59

Exercise scoped Logs group and stream permissions

• Adds checks for event, filter, and group operations against their named resources and for account- and region-scoped group tags. Revises stream tests to assert that streams do not inherit group resource tags.

src/test/java/io/floci/aws/services/iam/LogsStreamAuthorizationIntegrationTest.java

LogsUnknownRegionAuthorizationIntegrationTest.javaAdjust stream alias tests for tag-free streams +3/-5

Adjust stream alias tests for tag-free streams

• Removes group-resource-tag condition variants while retaining unknown-region and historical-name alias checks.

src/test/java/io/floci/aws/services/iam/LogsUnknownRegionAuthorizationIntegrationTest.java

ResourceArnBuilderTest.javaVerify table-derived Logs request targets +53/-48

Verify table-derived Logs request targets

• Tests bare group ARNs, stream and destination targets, tagging ARNs, partitions, and existing delivery mappings through the common builder. Removes expectations that supported event operations fall back to wildcard resources.

src/test/java/io/floci/aws/services/iam/ResourceArnBuilderTest.java

test_regen_iam_request_resources.pyRemove tests for obsolete partial-read overrides +0/-23

Remove tests for obsolete partial-read overrides

• Drops fixture setup and tests specific to READ_IN_HAND_BUILT, which the generator no longer supports.

tools/aws/test_regen_iam_request_resources.py

Documentation (2) +31 / -26
iam.mdDocument table-driven Logs authorization +26/-23

Document table-driven Logs authorization

• Moves Logs into the documented generated-table coverage and explains scoped group, stream, and tagging checks. Clarifies resource-tag behavior and legacy ARN compatibility.

docs/services/iam.md

StoredResourceArns.javaDescribe Logs stored-resource lookup coverage +5/-3

Describe Logs stored-resource lookup coverage

• Extends the interface documentation to include Logs delivery relationships and supported resource-tag lookups.

src/main/java/io/floci/aws/core/common/StoredResourceArns.java

@qodo-code-review

qodo-code-review Bot commented Nov 20, 2026 •

Copy link
Copy Markdown

Code Review by Qodo

🐞 Bugs (1) 📘 Rule violations (1) 🔗 Cross-repo conflicts (0) 📜 Skill insights (0)

Grey Divider


Action required

1. AWS-style group policies stop matching log reads ✗ Dismissed
Description
The table now checks group-level operations such as FilterLogEvents, DescribeLogStreams,
PutMetricFilter, PutSubscriptionFilter and StartQuery on the bare log-group:<name> ARN.
IamPolicyEvaluator.logGroupResourceAlias only extends :* matching to five management actions.
AWS evaluates these actions on log-group:<name>:log-stream:, so a policy written the usual AWS way
(log-group:<name>:*) is denied in Floci. A policy on the bare ARN, which AWS would not match, is
allowed here, and a bare-ARN Deny applies here although it does not on AWS.


Remediation recommended

2. Tagging during delete can bring back a deleted log group ✓ Resolved

Resolving commit: e37ede1

Resolution reason
Removed the method-level synchronized on both tagLogGroup and untagLogGroup and wrapped each body in
synchronized (metricFilterStore), the same monitor createLogGroup and deleteLogGroup use, so the
existence check, map replacement, and groupStore.put are atomic with respect to group lifecycle.
Javadoc updated to match.
Description
tagLogGroup and untagLogGroup now synchronize on the service instance, but createLogGroup and
deleteLogGroup synchronize on metricFilterStore, so the new lock does not serialize tag writes
with group lifecycle. A tag call that passes requireNamedLogGroup while a concurrent
deleteLogGroup removes the group then calls groupStore.put(key, group), which brings the deleted
group back without its streams and filters, despite the PR's claim that tags are written under the
service's lock.


Informational

3. A second log group name parser can drift 📘 Rule violation ⚙ Maintainability
Description
storedTags re-implements the log group ARN-to-name step that LogGroupTagTarget.resolve already
performs for the tag handlers: it strips the log-group: prefix and a trailing :* by hand, then
rejects names containing :. The tag handlers and this lookup must agree on which group a name
denotes, and the copy only stays correct while both are edited together. If the handlers' parsing
changes, storedTags will still read a different group, so the condition context and the tag call
can disagree about the same resource.
Code

src/main/java/io/floci/aws/services/cloudwatch/logs/CloudWatchLogsStoredResourceArns.java[R85-87]

+        if (resource.startsWith(LOG_GROUP)) {
+            String name = resource.substring(LOG_GROUP.length());
+            name = name.endsWith(ALL_STREAMS) ? name.substring(0, name.length() - ALL_STREAMS.length()) : name;
Relevance

● Weak

Duplicated-parser/helper suggestions were dismissed as rejected or false positive recently
(duplicate tag-key rules and isBlank helper).

PR-#9059
PR-#9064

ⓘ Recommendations generated based on similar findings in past PRs

Evidence
LogGroupTagTarget.resolve already owns the log group ARN-to-name rule (strip the log-group:
prefix, drop a trailing :*) for the tag handlers, and the new storedTags branch repeats that
rule with its own :* substring logic instead of reusing the helper. The rule asks that repeated
parsing of the same grammar be extracted to one shared helper, which this PR does not do.

Rule 4156683: Extract duplicated logic into a shared helper when the same code exists across tests or parsers
src/main/java/io/floci/aws/services/cloudwatch/logs/LogGroupTagTarget.java[14-24]

Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
CloudWatchLogsStoredResourceArns.storedTags parses a log group ARN by hand (strips the `log-group:` prefix, drops a trailing `:*`, rejects names containing `:`). LogGroupTagTarget.resolve already implements that same rule for the tag handlers, so the two can drift.

## Fix Focus Areas
- src/main/java/io/floci/aws/services/cloudwatch/logs/CloudWatchLogsStoredResourceArns.java[85-89]
- src/main/java/io/floci/aws/services/cloudwatch/logs/LogGroupTagTarget.java[14-24]

## Recommended Fix
Extract the name step of LogGroupTagTarget.resolve (prefix removal and trailing `:*` removal) into a static helper that both the tag handlers and storedTags call. Have storedTags call that helper with the parsed ARN resource, keeping its own account and Region checks and its rejection of names containing `:`. Confirm the existing tag tests and the IAM condition tests still pass.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Dismiss ↗ | View ↗


4. Log reads bypass group-specific denies 🐞 Bug ⛨ Security
Description
The new resource entries for DescribeLogStreams, FilterLogEvents, GetLogEvents, StartQuery,
AssociateKmsKey, and DisassociateKmsKey read only logGroupName, omitting supported selectors
such as logGroupIdentifier, logGroupNames, logGroupIdentifiers, and the KMS operations’
resourceIdentifier. When a caller uses an omitted selector, authorization checks * instead of
the selected group, so a wildcard allow can pass despite an explicit deny on that group’s ARN,
including for KMS-setting changes.
Code

src/main/resources/aws/iam-request-resources.json[3376]

+    "logs:FilterLogEvents": {"action": "logs:FilterLogEvents", "types": ["log-group"], "resources": [{"type": "log-group", "fill": {"LogGroupName": "logGroupName"}}]},
Relevance

● Weak

Same pattern dismissed intentionally: table entries filling only one selector, leaving alternate
selectors to be checked on '*'.

PR-#8426
PR-#9074

ⓘ Recommendations generated based on similar findings in past PRs

Evidence
The added entries name only logGroupName, while the read handlers accept alternate identifier or
list fields and the KMS handlers resolve resourceIdentifier to a group before calling the mutating
service method. When none of the configured resource fields is present, extraction produces no group
ARN and policy evaluation uses *; this applies to DescribeLogStreams, FilterLogEvents,
GetLogEvents, StartQuery, AssociateKmsKey, and DisassociateKmsKey.

src/main/resources/aws/iam-request-resources.json[3367-3367]
src/main/resources/aws/iam-request-resources.json[3376-3376]
src/main/resources/aws/iam-request-resources.json[3384-3384]
src/main/resources/aws/iam-request-resources.json[3427-3427]
src/main/java/io/floci/aws/services/cloudwatch/logs/CloudWatchLogsHandler.java[455-486]
src/main/java/io/floci/aws/services/cloudwatch/logs/CloudWatchLogsHandler.java[764-786]
src/main/java/io/floci/aws/services/iam/ResourceArnBuilder.java[180-189]
src/main/resources/aws/iam-request-resources.json[3322-3322]
src/main/resources/aws/iam-request-resources.json[3374-3374]
src/main/java/io/floci/aws/services/cloudwatch/logs/CloudWatchLogsHandler.java[556-599]

Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
Newly scoped log reads and KMS operations authorize on `*` when callers select groups through supported identifier or list fields omitted from their generated resource entries.

## Fix Focus Areas
- src/main/resources/aws/iam-request-resources.json[3322-3322]
- src/main/resources/aws/iam-request-resources.json[3367-3367]
- src/main/resources/aws/iam-request-resources.json[3374-3374]
- src/main/resources/aws/iam-request-resources.json[3376-3376]
- src/main/resources/aws/iam-request-resources.json[3384-3384]
- src/main/resources/aws/iam-request-resources.json[3427-3427]

## Recommended Fix
Update the generator’s resource mapping and regenerate the table so each operation resolves every group selector its handler accepts, including `resourceIdentifier` for both KMS operations and every group in `StartQuery` lists. Test identifier-only, ARN-form, and multi-group requests against a wildcard allow plus a group-specific explicit deny.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Dismiss ↗ | View ↗


Grey Divider

Context sources
✅ Compliance rules (platform): 21 rules
✅ Web pages:
  +2 more
✅ Cross-repo context — repo relationships
  Explored: repo: floci-io/testcontainers-floci (sha: e900a79e) — View relationship
  Explored: repo: floci-io/floci-ui (sha: 11c808ad) — View relationship
✅ Context preparation
  Past issues: summarized; full text retained for this review
Review mode: Auto: 🧠 Deep: IAM authorization, generated mappings, tagging, and concurrency create multiple defect-prone paths.

Grey Divider

Tip of the day
💡 Did you know, you can turn on the rule miner and Qodo learns your standards from review history

More tips ↗ | Customize Qodo ↗ | Qodo docs ↗

Grey Divider

Qodo Logo

@pgermosen
pgermosen force-pushed the fix/iam-logs-request-resources branch from 22da33c to e37ede1 Compare November 20, 2026 11:42
@pgermosen
pgermosen force-pushed the fix/iam-logs-request-resources branch from e37ede1 to 71b4017 Compare November 20, 2026 17:57
…from the generated table

CloudWatch Logs was built by hand: ResourceArnBuilder built a group or
stream ARN for six operations and resolved the tag operations' ARN
itself, every other Logs operation was checked on *, and only the
vended-log delivery operations and PutDestination were read from the
request resources table, through READ_IN_HAND_BUILT. logs moves from
HAND_BUILT to NAMESPACES, so the table gives each of its 118
operations the log group, stream, destination or delivery resource its
request names, from botocore and the Service Reference: PutLogEvents,
FilterLogEvents, metric and subscription filters, StartQuery and the
other operations on a group or stream are checked on it, no longer on
*. READ_IN_HAND_BUILT, whose only entries were Logs', goes with its
checks and tests. ResourceArnBuilder's buildLogResources and the
filter's Logs case go; the tagged CreateLogGroup check reads the
table's bare group ARN, which the evaluator already matches with or
without the trailing :* for the group's management actions.
CloudWatchLogsStoredResourceArns answers the stored tags of a log
group, a destination and the delivery family; IamConditionContextResolver
keeps only the request tags of Logs' create and tag calls. Log group
tag writes give the group a new map under the lock creating and
deleting a group take, so one racing a delete cannot put the group
back, and its tags field is volatile. Only Logs' operations change in
the table.
@pgermosen
pgermosen force-pushed the fix/iam-logs-request-resources branch from 71b4017 to 51e04ce Compare November 20, 2026 19:52
@pgermosen
pgermosen merged commit 3027145 into main Nov 20, 2026
26 of 27 checks passed
@pgermosen
pgermosen deleted the fix/iam-logs-request-resources branch November 20, 2026 20:21
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

bug Something isn't working cloudwatch Amazon CloudWatch (Logs & Metrics) iam AWS Identity and Access Management (IAM)

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant