AWS.ApplicationSignals reference

BatchGetServiceLevelObjectiveBudgetReport

Source: src/AWS/ApplicationSignals/BatchGetServiceLevelObjectiveBudgetReport.ts

Runtime binding for application-signals:BatchGetServiceLevelObjectiveBudgetReport, scoped to one ServiceLevelObjective.

Retrieves the bound SLO’s error-budget report — health indicator, attainment, and remaining budget — at the requested timestamp. Provide the implementation with Effect.provide(AWS.ApplicationSignals.BatchGetServiceLevelObjectiveBudgetReportHttp).

BatchGetServiceLevelObjectiveBudgetReport: Reading SLOs

// init — bind the operation to the SLO
const getBudgetReport =
  yield* AWS.ApplicationSignals.BatchGetServiceLevelObjectiveBudgetReport(slo);

// runtime — the SLO's ARN is injected as SloIds
const result = yield* getBudgetReport({ Timestamp: new Date() });
const report = result.Reports[0];
yield* Effect.log(`${report?.BudgetStatus}: ${report?.Attainment}%`);

BatchUpdateExclusionWindows

Source: src/AWS/ApplicationSignals/BatchUpdateExclusionWindows.ts

Runtime binding for application-signals:BatchUpdateExclusionWindows, scoped to one ServiceLevelObjective.

Adds or removes exclusion (maintenance) windows on the bound SLO — for example, automation that excludes a deployment window from SLO attainment. Provide the implementation with Effect.provide(AWS.ApplicationSignals.BatchUpdateExclusionWindowsHttp).

BatchUpdateExclusionWindows: Managing Exclusion Windows

// init — bind the operation to the SLO
const updateExclusionWindows =
  yield* AWS.ApplicationSignals.BatchUpdateExclusionWindows(slo);

// runtime — the SLO's ARN is injected as SloIds
yield* updateExclusionWindows({
  AddExclusionWindows: [
    {
      StartTime: new Date(),
      Window: { DurationUnit: "HOUR", Duration: 2 },
      Reason: "scheduled maintenance",
    },
  ],
});

Discovery

Source: src/AWS/ApplicationSignals/Discovery.ts

Enables CloudWatch Application Signals for this account by creating the AWSServiceRoleForCloudWatchApplicationSignals service-linked role and the service-linked CloudTrail event channel used for change-event correlation (mirrors CloudFormation’s AWS::ApplicationSignals::Discovery).

StartDiscovery is idempotent, and AWS provides no API to disable discovery or observe its enablement, so this resource is provision-only: deleting it from the stack leaves discovery enabled (the delete is a no-op, matching CloudFormation’s behavior).

Discovery: Enabling Application Signals

import * as AWS from "alchemy/AWS";

const discovery = yield* AWS.ApplicationSignals.Discovery("Discovery", {});

GetInstrumentationConfigurationStatus

Source: src/AWS/ApplicationSignals/GetInstrumentationConfigurationStatus.ts

Runtime binding for application-signals:GetInstrumentationConfigurationStatus, scoped to one InstrumentationConfiguration.

Returns the status history (READY/ERROR/ACTIVE/DISABLED) that instrumented SDK agents reported for the bound configuration during a time range. Provide the implementation with Effect.provide(AWS.ApplicationSignals.GetInstrumentationConfigurationStatusHttp).

GetInstrumentationConfigurationStatus: Monitoring Instrumentation

// init — bind the operation to the configuration
const getStatus =
  yield* AWS.ApplicationSignals.GetInstrumentationConfigurationStatus(probe);

// runtime — the configuration's identity is injected automatically
const result = yield* getStatus({ Status: "ACTIVE" });
yield* Effect.log(`${result.Events.length} ACTIVE events`);

GetService

Source: src/AWS/ApplicationSignals/GetService.ts

Runtime binding for application-signals:GetService.

Returns information about one service discovered by Application Signals, identified by its KeyAttributes (Type/Name/Environment). Provide the implementation with Effect.provide(AWS.ApplicationSignals.GetServiceHttp).

GetService: Discovering Services

// init — account-level, no resource argument
const getService = yield* AWS.ApplicationSignals.GetService();

// runtime
const result = yield* getService({
  StartTime: new Date(Date.now() - 3600_000),
  EndTime: new Date(),
  KeyAttributes: {
    Type: "Service",
    Name: "checkout-service",
    Environment: "eks:prod",
  },
});

GetServiceLevelObjective

Source: src/AWS/ApplicationSignals/GetServiceLevelObjective.ts

Runtime binding for application-signals:GetServiceLevelObjective, scoped to one ServiceLevelObjective.

Returns the bound SLO’s full configuration (SLI, goal, burn rates). Provide the implementation with Effect.provide(AWS.ApplicationSignals.GetServiceLevelObjectiveHttp).

GetServiceLevelObjective: Reading SLOs

// init — bind the operation to the SLO
const getSlo = yield* AWS.ApplicationSignals.GetServiceLevelObjective(slo);

// runtime — the SLO's ARN is injected automatically
const result = yield* getSlo();
yield* Effect.log(result.Slo.Goal.AttainmentGoal);

GroupingConfiguration

Source: src/AWS/ApplicationSignals/GroupingConfiguration.ts

The CloudWatch Application Signals grouping configuration for this account — an account-level singleton that defines custom grouping attributes (sourced from telemetry attributes or AWS tags) used to organize and filter discovered services in the Application Signals console and APIs.

There is at most ONE grouping configuration per account/region; PutGroupingConfiguration replaces the whole definition list.

GroupingConfiguration: Creating a Grouping Configuration

Group Services by Team Tag

import * as AWS from "alchemy/AWS";

const grouping = yield* AWS.ApplicationSignals.GroupingConfiguration(
  "Grouping",
  {
    groupingAttributeDefinitions: [
      {
        GroupingName: "Team",
        GroupingSourceKeys: ["Tag.team"],
        DefaultGroupingValue: "unassigned",
      },
    ],
  },
);

Multiple Grouping Dimensions

const grouping = yield* AWS.ApplicationSignals.GroupingConfiguration(
  "Grouping",
  {
    groupingAttributeDefinitions: [
      { GroupingName: "Team", GroupingSourceKeys: ["Tag.team"] },
      {
        GroupingName: "CostCenter",
        GroupingSourceKeys: ["Tag.cost-center", "business_unit"],
        DefaultGroupingValue: "shared",
      },
    ],
  },
);

InstrumentationConfiguration

Source: src/AWS/ApplicationSignals/InstrumentationConfiguration.ts

A CloudWatch Application Signals dynamic instrumentation configuration — instructs instrumented SDK agents to capture a snapshot (arguments, locals, return value, stack trace) at a specific code location of a discovered service, without redeploying the application.

Configurations are immutable after creation: every change except tags replaces the configuration. Tags remain mutable through the standard tagging APIs.

InstrumentationConfiguration: Creating an Instrumentation Configuration

Snapshot Probe on a Python Method

import * as AWS from "alchemy/AWS";

const probe = yield* AWS.ApplicationSignals.InstrumentationConfiguration(
  "CheckoutProbe",
  {
    instrumentationType: "PROBE",
    service: "checkout-service",
    environment: "eks:prod",
    signalType: "SNAPSHOT",
    location: {
      Language: "Python",
      CodeUnit: "app.checkout",
      MethodName: "process_order",
      FilePath: "app/checkout.py",
      LineNumber: 42,
    },
    captureConfiguration: {
      CaptureLocals: ["order_id", "total"],
      CaptureLimits: { MaxHits: 100 },
    },
  },
);

Expiring Probe with Attribute Filters

const probe = yield* AWS.ApplicationSignals.InstrumentationConfiguration(
  "DebugProbe",
  {
    instrumentationType: "PROBE",
    service: "checkout-service",
    environment: "eks:prod",
    signalType: "SNAPSHOT",
    location: {
      Language: "Java",
      ClassName: "com.example.Checkout",
      MethodName: "processOrder",
      FilePath: "src/main/java/com/example/Checkout.java",
    },
    captureConfiguration: {
      CaptureArguments: ["order"],
      CaptureLimits: { MaxHits: 10 },
    },
    expiresAt: new Date(Date.now() + 24 * 3600 * 1000),
    attributeFilters: [{ "aws.local.operation": "POST /checkout" }],
  },
);

ListAuditFindings

Source: src/AWS/ApplicationSignals/ListAuditFindings.ts

Runtime binding for application-signals:ListAuditFindings.

Returns audit findings — automated analysis of service behavior and root causes (performance issues, anomalies, potential problems) for the given audit targets. Provide the implementation with Effect.provide(AWS.ApplicationSignals.ListAuditFindingsHttp).

ListAuditFindings: Auditing Services

// init — account-level, no resource argument
const listAuditFindings = yield* AWS.ApplicationSignals.ListAuditFindings();

// runtime
const result = yield* listAuditFindings({
  StartTime: new Date(Date.now() - 3600_000),
  EndTime: new Date(),
  AuditTargets: [
    {
      Type: "service",
      Data: {
        Service: {
          Type: "Service",
          Name: "checkout-service",
          Environment: "eks:prod",
        },
      },
    },
  ],
});

ListEntityEvents

Source: src/AWS/ApplicationSignals/ListEntityEvents.ts

Runtime binding for application-signals:ListEntityEvents.

Lists change events (deployments, configuration changes, and other state-changing activities) for a specific entity. Provide the implementation with Effect.provide(AWS.ApplicationSignals.ListEntityEventsHttp).

ListEntityEvents: Tracking Changes

// init — account-level, no resource argument
const listEntityEvents = yield* AWS.ApplicationSignals.ListEntityEvents();

// runtime
const page = yield* listEntityEvents({
  Entity: {
    Type: "Service",
    Name: "checkout-service",
    Environment: "eks:prod",
  },
  StartTime: new Date(Date.now() - 24 * 3600_000),
  EndTime: new Date(),
});

ListServiceDependencies

Source: src/AWS/ApplicationSignals/ListServiceDependencies.ts

Runtime binding for application-signals:ListServiceDependencies.

Lists the dependencies (AWS services, resources, and third-party services) that a discovered service’s operations connect with. Provide the implementation with Effect.provide(AWS.ApplicationSignals.ListServiceDependenciesHttp).

ListServiceDependencies: Exploring the Service Topology

// init — account-level, no resource argument
const listServiceDependencies =
  yield* AWS.ApplicationSignals.ListServiceDependencies();

// runtime
const page = yield* listServiceDependencies({
  StartTime: new Date(Date.now() - 3600_000),
  EndTime: new Date(),
  KeyAttributes: {
    Type: "Service",
    Name: "checkout-service",
    Environment: "eks:prod",
  },
});

ListServiceDependents

Source: src/AWS/ApplicationSignals/ListServiceDependents.ts

Runtime binding for application-signals:ListServiceDependents.

Lists the dependents (other services, Synthetics canaries, RUM app monitors) that invoked a discovered service during a time range. Provide the implementation with Effect.provide(AWS.ApplicationSignals.ListServiceDependentsHttp).

ListServiceDependents: Exploring the Service Topology

// init — account-level, no resource argument
const listServiceDependents =
  yield* AWS.ApplicationSignals.ListServiceDependents();

// runtime
const page = yield* listServiceDependents({
  StartTime: new Date(Date.now() - 3600_000),
  EndTime: new Date(),
  KeyAttributes: {
    Type: "Service",
    Name: "checkout-service",
    Environment: "eks:prod",
  },
});

ListServiceLevelObjectiveExclusionWindows

Source: src/AWS/ApplicationSignals/ListServiceLevelObjectiveExclusionWindows.ts

Runtime binding for application-signals:ListServiceLevelObjectiveExclusionWindows, scoped to one ServiceLevelObjective.

Lists the exclusion (maintenance) windows configured on the bound SLO. Provide the implementation with Effect.provide(AWS.ApplicationSignals.ListServiceLevelObjectiveExclusionWindowsHttp).

ListServiceLevelObjectiveExclusionWindows: Managing Exclusion Windows

// init — bind the operation to the SLO
const listExclusionWindows =
  yield* AWS.ApplicationSignals.ListServiceLevelObjectiveExclusionWindows(slo);

// runtime — the SLO's ARN is injected as Id
const page = yield* listExclusionWindows();
yield* Effect.log(`${page.ExclusionWindows.length} windows`);

ListServiceLevelObjectives

Source: src/AWS/ApplicationSignals/ListServiceLevelObjectives.ts

Runtime binding for application-signals:ListServiceLevelObjectives.

Lists the service level objectives in this account, optionally filtered by service key attributes, operation name, or dependency config. Provide the implementation with Effect.provide(AWS.ApplicationSignals.ListServiceLevelObjectivesHttp).

ListServiceLevelObjectives: Listing Service Level Objectives

// init — account-level, no resource argument
const listSlos = yield* AWS.ApplicationSignals.ListServiceLevelObjectives();

// runtime
const page = yield* listSlos({});
for (const slo of page.SloSummaries) {
  yield* Effect.log(`${slo.Name}: ${slo.Arn}`);
}

ListServiceOperations

Source: src/AWS/ApplicationSignals/ListServiceOperations.ts

Runtime binding for application-signals:ListServiceOperations.

Lists the operations of a discovered service that were invoked during a time range. Provide the implementation with Effect.provide(AWS.ApplicationSignals.ListServiceOperationsHttp).

ListServiceOperations: Exploring the Service Topology

// init — account-level, no resource argument
const listServiceOperations =
  yield* AWS.ApplicationSignals.ListServiceOperations();

// runtime
const page = yield* listServiceOperations({
  StartTime: new Date(Date.now() - 3600_000),
  EndTime: new Date(),
  KeyAttributes: {
    Type: "Service",
    Name: "checkout-service",
    Environment: "eks:prod",
  },
});

ListServices

Source: src/AWS/ApplicationSignals/ListServices.ts

Runtime binding for application-signals:ListServices.

Lists the services discovered by Application Signals during a time range. Provide the implementation with Effect.provide(AWS.ApplicationSignals.ListServicesHttp).

ListServices: Discovering Services

// init — account-level, no resource argument
const listServices = yield* AWS.ApplicationSignals.ListServices();

// runtime
const page = yield* listServices({
  StartTime: new Date(Date.now() - 3600_000),
  EndTime: new Date(),
});
for (const service of page.ServiceSummaries) {
  yield* Effect.log(service.KeyAttributes?.Name);
}

ListServiceStates

Source: src/AWS/ApplicationSignals/ListServiceStates.ts

Runtime binding for application-signals:ListServiceStates.

Returns the last deployment and other change states of discovered services — visibility into recent changes for troubleshooting and change correlation. Provide the implementation with Effect.provide(AWS.ApplicationSignals.ListServiceStatesHttp).

ListServiceStates: Tracking Changes

// init — account-level, no resource argument
const listServiceStates = yield* AWS.ApplicationSignals.ListServiceStates();

// runtime
const page = yield* listServiceStates({
  StartTime: new Date(Date.now() - 24 * 3600_000),
  EndTime: new Date(),
});

ServiceLevelObjective

Source: src/AWS/ApplicationSignals/ServiceLevelObjective.ts

A CloudWatch Application Signals service level objective (SLO) that tracks an attainment goal against a service level indicator — any CloudWatch metric or metric-math expression, or a service operation discovered by Application Signals.

ServiceLevelObjective: Creating Service Level Objectives

Period-based SLO on a CloudWatch metric

import * as ApplicationSignals from "alchemy/AWS/ApplicationSignals";

const slo = yield* ApplicationSignals.ServiceLevelObjective("ApiLatency", {
  description: "p99 latency under 2 seconds",
  sliConfig: {
    SliMetricConfig: {
      MetricDataQueries: [
        {
          Id: "m1",
          MetricStat: {
            Metric: {
              Namespace: "AWS/Lambda",
              MetricName: "Duration",
              Dimensions: [{ Name: "FunctionName", Value: "my-api" }],
            },
            Period: 60,
            Stat: "p99",
          },
          ReturnData: true,
        },
      ],
    },
    MetricThreshold: 2000,
    ComparisonOperator: "LessThanOrEqualTo",
  },
  goal: {
    Interval: { RollingInterval: { DurationUnit: "DAY", Duration: 7 } },
    AttainmentGoal: 99,
    WarningThreshold: 50,
  },
});

Request-based SLO

const slo = yield* ApplicationSignals.ServiceLevelObjective("Availability", {
  requestBasedSliConfig: {
    RequestBasedSliMetricConfig: {
      TotalRequestCountMetric: [
        {
          Id: "total",
          MetricStat: {
            Metric: { Namespace: "AWS/ApplicationELB", MetricName: "RequestCount" },
            Period: 60,
            Stat: "Sum",
          },
          ReturnData: true,
        },
      ],
      MonitoredRequestCountMetric: {
        BadCountMetric: [
          {
            Id: "bad",
            MetricStat: {
              Metric: { Namespace: "AWS/ApplicationELB", MetricName: "HTTPCode_Target_5XX_Count" },
              Period: 60,
              Stat: "Sum",
            },
            ReturnData: true,
          },
        ],
      },
    },
  },
  goal: { AttainmentGoal: 99.9 },
});