> ## Documentation Index
> Fetch the complete documentation index at: https://docs.appsignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Exemples de mutations de l'API GraphQL

L'[API GraphQL](/api/graphql) d'AppSignal prend en charge les mutations en plus
des requêtes. Là où une [requête](/api/graphql/examples) lit des données, une
mutation les écrit : vous pouvez créer un marqueur personnalisé, fermer un
incident, ajouter un moniteur de disponibilité, et plus encore.

Les mutations utilisent le même point de terminaison et le même jeton d'API
personnel que les requêtes. Consultez la [page de l'API GraphQL](/api/graphql)
pour plus de détails sur le point de terminaison et l'authentification.

La plupart des mutations sont liées à une app et prennent un argument `appId`
qui limite la modification à une seule app. Vous pouvez trouver l'ID de votre
app dans l'[écran des paramètres](https://appsignal.com/redirect-to/app?to=admin/api_keys)
de votre app. Certaines mutations sont liées à une organisation et prennent un
argument `organizationSlug` à la place, comme `createApp` et `createStatusPage`.

Cette page couvre les mutations les plus courantes. Pour la liste complète et
générée automatiquement de chaque mutation et de ses arguments, consultez la
[référence du schéma GraphQL](https://appsignal.com/graphql/docs).

<Note>
  Les mutations modifient les données de votre compte. Testez sur une app
  hors production avant d'automatiser une mutation sur des données de
  production.
</Note>

## Incidents

### Mettre à jour un incident

Modifiez l'état, la gravité, les personnes assignées ou les paramètres de
notification d'un incident. Le `number` est le numéro d'incident affiché dans
AppSignal.

`state` accepte `OPEN`, `WIP` ou `CLOSED`. `severity` accepte `UNTRIAGED`,
`CRITICAL`, `HIGH`, `LOW`, `NONE` ou `INFORMATIONAL`.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation UpdateIncident(
    $appId: String!
    $number: Int!
    $state: IncidentStateEnum
    $severity: IncidentSeverityEnum
    $assigneeIds: [String!]
  ) {
    updateIncident(
      appId: $appId
      number: $number
      state: $state
      severity: $severity
      assigneeIds: $assigneeIds
    ) {
      ... on ExceptionIncident {
        id
        number
        state
        severity
      }
      ... on PerformanceIncident {
        id
        number
        state
        severity
      }
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "number": 42,
    "state": "CLOSED",
    "severity": "LOW"
  }
  ```
</CodeGroup>

### Mise à jour groupée d'incidents

Mettez à jour plusieurs incidents en une seule requête. Contrairement à
`updateIncident`, cette mutation prend les IDs d'incident plutôt que les
numéros d'incident.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation BulkUpdateIncidents(
    $appId: String!
    $ids: [String]!
    $state: IncidentStateEnum
    $severity: IncidentSeverityEnum
  ) {
    bulkUpdateIncidents(
      appId: $appId
      ids: $ids
      state: $state
      severity: $severity
    ) {
      ... on ExceptionIncident {
        id
        number
        state
      }
      ... on PerformanceIncident {
        id
        number
        state
      }
      ... on AnomalyIncident {
        id
        number
        state
      }
      ... on LogIncident {
        id
        number
        state
      }
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "ids": ["INCIDENT-ID-1", "INCIDENT-ID-2"],
    "state": "CLOSED"
  }
  ```
</CodeGroup>

### Créer une note sur un incident

Ajoutez une note au journal d'un incident. Les mêmes champs sont disponibles
sur les incidents de performance, d'anomalie et de journal.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateIncidentNote(
    $appId: String!
    $incidentNumber: Int!
    $content: String!
  ) {
    createIncidentNote(
      appId: $appId
      incidentNumber: $incidentNumber
      content: $content
    ) {
      ... on ExceptionIncident {
        id
        number
        logbook {
          items {
            ... on Note {
              id
              content
              createdAt
            }
          }
        }
      }
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "incidentNumber": 42,
    "content": "Investigating, deploy reverted."
  }
  ```
</CodeGroup>

### Créer un ticket à partir d'un incident

Créez un ticket lié dans une intégration connectée. Cet exemple utilise GitHub ;
des mutations équivalentes existent pour d'autres intégrations :
`createGitlabIssue`, `createJiraIssue`, `createLinearIssue`,
`createShortcutStory`, `createAsanaTask` et `createTrelloCard`.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateGithubIssue(
    $appId: String!
    $incidentNumber: Int!
    $title: String!
    $description: String!
  ) {
    createGithubIssue(
      appId: $appId
      incidentNumber: $incidentNumber
      title: $title
      description: $description
    ) {
      ... on ExceptionIncident {
        id
        number
        integrations {
          ... on GitHub {
            name
            issues {
              url
              title
            }
          }
        }
      }
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "incidentNumber": 42,
    "title": "NoMethodError in OrdersController#create",
    "description": "Tracked in AppSignal incident #42."
  }
  ```
</CodeGroup>

### Supprimer une intégration d'un incident

Supprimez un ticket d'intégration précédemment lié à un incident.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation RemoveIntegration(
    $appId: String!
    $incidentNumber: Int!
    $id: String!
  ) {
    removeIntegration(
      appId: $appId
      incidentNumber: $incidentNumber
      id: $id
    ) {
      ... on ExceptionIncident {
        id
        number
      }
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "incidentNumber": 42,
    "id": "YOUR-INTEGRATION-ID"
  }
  ```
</CodeGroup>

## Marqueurs

### Créer ou mettre à jour un marqueur personnalisé

Créez un marqueur personnalisé pour annoter un instant donné, tel qu'un
changement de configuration ou une action manuelle. Passez un `id` pour mettre
à jour un marqueur existant. Omettez `id` pour créer un nouveau marqueur.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateCustomMarker(
    $appId: String!
    $id: String
    $icon: String!
    $message: String
    $createdAt: DateTime
  ) {
    createOrUpdateCustomMarker(
      appId: $appId
      id: $id
      icon: $icon
      message: $message
      createdAt: $createdAt
    ) {
      id
      icon
      message
      createdAt
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "icon": "🚀",
    "message": "Ran database migration"
  }
  ```
</CodeGroup>

### Supprimer un marqueur personnalisé

Supprimez un marqueur personnalisé par ID.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation DeleteCustomMarker($appId: String!, $id: String!) {
    deleteCustomMarker(appId: $appId, id: $id) {
      id
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-MARKER-ID"
  }
  ```
</CodeGroup>

## Alertes et déclencheurs

### Créer un déclencheur

Créez un déclencheur d'alerte basé sur une métrique. `field` accepte une valeur
de `MetricFieldEnum` (telle que `MEAN`, `P90`, `P95`, `COUNT`, `GAUGE` ou
`COUNTER`). `kind` est une chaîne décrivant le type de déclencheur. La
documentation source GraphQL nomme `ExceptionRate` et `Throughput` comme
exemples. La `condition` définit le seuil de comparaison. Pour remplacer un
déclencheur existant, passez son ID en tant que `previousTriggerId`.

`comparisonOperator` accepte `LESS_THAN`, `GREATER_THAN`, `LESS_THAN_OR_EQUAL`,
`GREATER_THAN_OR_EQUAL`, `EQUAL` ou `NOT_EQUAL`.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateTrigger(
    $appId: String!
    $previousTriggerId: String
    $name: String
    $metricName: String!
    $kind: String!
    $field: MetricFieldEnum!
    $condition: ThresholdConditionInput!
    $warmupDuration: Int!
    $cooldownDuration: Int!
    $notifierIds: [String!]
  ) {
    createTrigger(
      appId: $appId
      previousTriggerId: $previousTriggerId
      name: $name
      metricName: $metricName
      kind: $kind
      field: $field
      condition: $condition
      warmupDuration: $warmupDuration
      cooldownDuration: $cooldownDuration
      notifierIds: $notifierIds
    ) {
      id
      name
      metricName
      field
      thresholdCondition {
        value
        comparisonOperator
      }
      warmupDuration
      cooldownDuration
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "name": "High error rate",
    "metricName": "transaction_exception_count",
    "kind": "ExceptionRate",
    "field": "COUNTER",
    "condition": { "value": 10, "comparisonOperator": "GREATER_THAN" },
    "warmupDuration": 0,
    "cooldownDuration": 5,
    "notifierIds": ["YOUR-NOTIFIER-ID"]
  }
  ```
</CodeGroup>

### Archiver un déclencheur

Archivez un déclencheur afin qu'il n'évalue plus de métriques ni n'envoie
d'alertes.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation ArchiveTrigger($appId: String!, $id: String!) {
    archiveTrigger(appId: $appId, id: $id) {
      id
      name
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-TRIGGER-ID"
  }
  ```
</CodeGroup>

### Archiver une alerte

Archivez une seule alerte déclenchée. Cette mutation retourne `true` en cas de
succès.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation ArchiveAlert($appId: String!, $id: String!) {
    archiveAlert(appId: $appId, id: $id)
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-ALERT-ID"
  }
  ```
</CodeGroup>

### Fermer la dernière alerte d'un incident d'anomalie

Fermez l'alerte ouverte la plus récente pour un incident d'anomalie, identifié
par son numéro d'incident.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation EndLastAlert($appId: String!, $number: Int!) {
    endLastAlert(appId: $appId, number: $number) {
      id
      number
      alertState
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "number": 42
  }
  ```
</CodeGroup>

## Moniteurs de disponibilité

### Créer un moniteur de disponibilité

Créez un moniteur de disponibilité à partir d'un `UptimeMonitorInput`.
`regions` accepte une ou plusieurs valeurs parmi `EUROPE`, `NORTH_AMERICA`,
`ASIA_PACIFIC` ou `SOUTH_AMERICA`.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateUptimeMonitor(
    $appId: String!
    $uptimeMonitor: UptimeMonitorInput!
  ) {
    createUptimeMonitor(appId: $appId, uptimeMonitor: $uptimeMonitor) {
      id
      name
      url
      regions
      warmupDuration
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "uptimeMonitor": {
      "name": "Marketing site",
      "url": "https://example.com",
      "regions": ["EUROPE", "NORTH_AMERICA"],
      "warmupDuration": 1,
      "notifierIds": ["YOUR-NOTIFIER-ID"]
    }
  }
  ```
</CodeGroup>

### Mettre à jour un moniteur de disponibilité

Mettez à jour un moniteur existant. L'entrée `uptimeMonitor` prend la même
forme que lors de la création.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation UpdateUptimeMonitor(
    $appId: String!
    $id: String!
    $uptimeMonitor: UptimeMonitorInput!
  ) {
    updateUptimeMonitor(
      appId: $appId
      id: $id
      uptimeMonitor: $uptimeMonitor
    ) {
      id
      name
      url
      regions
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-UPTIME-MONITOR-ID",
    "uptimeMonitor": {
      "name": "Marketing site",
      "url": "https://example.com/health",
      "regions": ["EUROPE"]
    }
  }
  ```
</CodeGroup>

### Supprimer un moniteur de disponibilité

Supprimez un moniteur par ID. Cette mutation retourne le moniteur supprimé.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation DeleteUptimeMonitor($appId: String!, $id: String!) {
    deleteUptimeMonitor(appId: $appId, id: $id) {
      id
      name
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-UPTIME-MONITOR-ID"
  }
  ```
</CodeGroup>

## Check-ins

### Créer un déclencheur de check-in

Créez un déclencheur de check-in cron ou heartbeat. `kind` accepte `CRON` ou
`HEARTBEAT`. Pour un déclencheur cron, définissez `syntax` sur l'expression
cron. Utilisez UTC pour `timezone` lorsque cela est possible.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateCheckInTrigger(
    $appId: String!
    $identifier: String!
    $kind: CheckInTriggerKindEnum!
    $waitTimeMinutes: Int!
    $syntax: String
    $timezone: String
    $notifierIds: [String!]
  ) {
    createCheckInTrigger(
      appId: $appId
      identifier: $identifier
      kind: $kind
      waitTimeMinutes: $waitTimeMinutes
      syntax: $syntax
      timezone: $timezone
      notifierIds: $notifierIds
    ) {
      id
      identifier
      kind
      syntax
      timezone
      waitTimeMinutes
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "identifier": "nightly-backup",
    "kind": "CRON",
    "syntax": "0 2 * * *",
    "timezone": "UTC",
    "waitTimeMinutes": 5,
    "notifierIds": ["YOUR-NOTIFIER-ID"]
  }
  ```
</CodeGroup>

### Mettre à jour un déclencheur de check-in

Mettez à jour un déclencheur de check-in existant. Seuls les champs que vous
passez sont modifiés.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation UpdateCheckInTrigger(
    $appId: String!
    $id: String!
    $syntax: String
    $waitTimeMinutes: Int
    $notifierIds: [String!]
  ) {
    updateCheckInTrigger(
      appId: $appId
      id: $id
      syntax: $syntax
      waitTimeMinutes: $waitTimeMinutes
      notifierIds: $notifierIds
    ) {
      id
      identifier
      syntax
      waitTimeMinutes
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-CHECK-IN-TRIGGER-ID",
    "syntax": "0 3 * * *",
    "waitTimeMinutes": 10
  }
  ```
</CodeGroup>

### Supprimer un déclencheur de check-in

Supprimez un déclencheur de check-in par ID.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation DeleteCheckInTrigger($appId: String!, $id: String!) {
    deleteCheckInTrigger(appId: $appId, id: $id) {
      id
      identifier
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-CHECK-IN-TRIGGER-ID"
  }
  ```
</CodeGroup>

## Tableaux de bord

### Créer un tableau de bord

Créez un tableau de bord vide. Ajoutez-y des visuels avec les mutations
`createVisualTimeseries` et `createVisualNumber`, ou importez un tableau de
bord complet avec `importDashboard`.

Les visuels de tableau de bord sont également gérés via
`createVisualTimeseries`, `createVisualNumber`, `updateVisualTimeseries`,
`updateVisualNumber`, `updateVisualLayouts` et `deleteVisual`. Pour créer un
visuel enregistré autonome récupérable ultérieurement via les [points de
terminaison REST des visuels enregistrés](/api/v2/saved-visuals), utilisez
`createSavedVisual`.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateDashboard(
    $appId: String!
    $title: String!
    $description: String
  ) {
    createDashboard(appId: $appId, title: $title, description: $description) {
      id
      title
      description
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "title": "Background jobs",
    "description": "Throughput and queue time for worker jobs."
  }
  ```
</CodeGroup>

### Mettre à jour un tableau de bord

Mettez à jour le titre ou la description d'un tableau de bord. Le `title` est
obligatoire.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation UpdateDashboard(
    $appId: String!
    $id: String!
    $title: String!
    $description: String
  ) {
    updateDashboard(
      appId: $appId
      id: $id
      title: $title
      description: $description
    ) {
      id
      title
      description
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-DASHBOARD-ID",
    "title": "Background jobs",
    "description": "Updated description."
  }
  ```
</CodeGroup>

### Supprimer un tableau de bord

Supprimez un tableau de bord par ID.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation DeleteDashboard($appId: String!, $id: String!) {
    deleteDashboard(appId: $appId, id: $id) {
      id
      title
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "id": "YOUR-DASHBOARD-ID"
  }
  ```
</CodeGroup>

### Importer un tableau de bord

Importez un tableau de bord à partir d'une définition JSON. L'argument `json`
est une chaîne encodée en JSON, donc échappez-la lorsque vous l'envoyez en
tant que variable.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation ImportDashboard($appId: String!, $json: String!) {
    importDashboard(appId: $appId, json: $json) {
      id
      title
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "json": "{\"title\":\"Imported dashboard\",\"visuals\":[]}"
  }
  ```
</CodeGroup>

## Journaux

### Créer un déclencheur de journal

Créez un déclencheur qui ouvre un incident lorsque des lignes de journal
correspondent à une requête. `severities` accepte les noms de gravité de
journal tels que `error`, `warn` ou `info`.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateLogTrigger(
    $appId: String!
    $name: String!
    $query: String!
    $sourceIds: [String!]
    $severities: [String!]
    $notifierIds: [String!]
  ) {
    createLogTrigger(
      appId: $appId
      name: $name
      query: $query
      sourceIds: $sourceIds
      severities: $severities
      notifierIds: $notifierIds
    ) {
      id
      name
      query
      severities
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "appId": "YOUR-APP-ID",
    "name": "Payment errors",
    "query": "payment failed",
    "severities": ["error"],
    "notifierIds": ["YOUR-NOTIFIER-ID"]
  }
  ```
</CodeGroup>

Les journaux sont également gérés via GraphQL au-delà des déclencheurs.
Utilisez `createLogSource`, `updateLogSource` et `deleteLogSource` pour les
sources ; `createLogView`, `updateLogView` et `deleteLogView` pour les vues
enregistrées ; `createLogLineAction`, `updateLogLineAction`,
`deleteLogLineAction` et `reorderLogLineActions` pour les règles d'ingestion ;
`updateLogTrigger` et `deleteLogTrigger` pour les déclencheurs de journal ; et
`createLogExport`, `updateLogExport` et `deleteLogExport` pour les exports S3.

## Mutations à l'échelle de l'organisation

Certaines mutations agissent sur une organisation plutôt que sur une seule
app, et prennent donc un argument `organizationSlug` au lieu de `appId`. Vous
pouvez trouver le slug dans l'URL de votre organisation dans AppSignal.

### Créer une app

Créez une nouvelle app au sein d'une organisation.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateApp(
    $organizationSlug: String!
    $name: String!
    $environment: String!
  ) {
    createApp(
      organizationSlug: $organizationSlug
      name: $name
      environment: $environment
    ) {
      id
      name
      environment
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "organizationSlug": "YOUR-ORGANIZATION-SLUG",
    "name": "My app",
    "environment": "production"
  }
  ```
</CodeGroup>

### Créer une page de statut

Créez une page de statut publique à partir d'un `CreateStatusPageInput`.
`title` et `hostname` sont obligatoires.

<CodeGroup>
  ```graphql Mutation theme={null}
  mutation CreateStatusPage(
    $organizationSlug: String!
    $statusPage: CreateStatusPageInput!
  ) {
    createStatusPage(
      organizationSlug: $organizationSlug
      statusPage: $statusPage
    ) {
      id
      title
      hostname
      state
    }
  }
  ```
</CodeGroup>

<CodeGroup>
  ```json Variables theme={null}
  {
    "organizationSlug": "YOUR-ORGANIZATION-SLUG",
    "statusPage": {
      "title": "Service status",
      "hostname": "status.example.com",
      "uptimeMonitorIds": ["YOUR-UPTIME-MONITOR-ID"],
      "threshold": 1
    }
  }
  ```
</CodeGroup>

Les pages de statut prennent également en charge `createStatusPageUpdate`,
`updateStatusPage`, `updateStatusPageUpdate`, `deleteStatusPage` et
`deleteStatusPageUpdate`. Pour les exports CSV, utilisez `createCsvExport`
pour démarrer un export et `createCsvExportUrl` pour générer une URL de
téléchargement pour un export terminé.

## Autres mutations

Ces exemples couvrent les opérations les plus courantes. L'API en contient
davantage, regroupées dans la référence du schéma sous Core (gestion des apps
et des collecteurs hébergés), Tableaux de bord (visuels et mises en page),
Journaux (sources, vues et exports), Exports (CSV), Pages de statut (mises à
jour) et Préférences utilisateur. Pour la liste complète des mutations et de
leurs arguments, consultez la [référence du schéma
GraphQL](https://appsignal.com/graphql/docs).