s3ConfigureArchiving()

The s3ConfigureArchiving() GraphQL mutation is used to configure S3 archiving for a repository (e.g., bucket and region). Before configuring S3 archiving, you may want to run s3ArchivingRequiresRole() to check whether an AWS role is required.

To enable and disable S3 archiving for a respository, use the s3EnableArchiving() and s3DisableArchiving() mutations. To reset S3 archiving (i.e., to mark all segment files as unarchived), use s3ResetArchiving().

Hide Query Example

Show S3 Archiving Query

To get information on the S3 archiving configuration for a repository, you could use the repository() query like this:

graphql

query {
     repository ( name: "humio" )
      { s3ArchivingConfiguration { bucket, disabled, startFrom } }
   }

For more information on S3 storage, see the S3 Archiving documentation page.

API Stability Short-Term

Syntax

graphql

s3ConfigureArchiving(
     repositoryName: string!,
     bucket: string!,
     region: string!,
     format: S3ArchivingFormat!,
     tagOrderInName: [string],
     startFromDateTime: datetime,
     endAtDateTime: datetime, 
     roleArn: string
   ): BooleanResultType!

You'll have to specify the name of the repository, the AWS region, and the S3 bucket and archiving format to use. You may also give the start and end dates for archiving. See the tables in the Given Datatype section for details on the input parameters.

For the results, you'll receive confirmation if successful through a simple parameter. See the Returned Datatype section.

Example

Raw

graphql

mutation {
  s3ConfigureArchiving(
    repositoryName: "humio",
    bucket: "pale-1",
    region: "us-west-1",
    format: RAW,
    tagOrderInName: ["admin", "other"]
  )
  { result }
}

Mac OS or Linux (curl)

shell

curl -v -X POST $YOUR_LOGSCALE_URL/graphql \
    -H "Authorization: Bearer $TOKEN" \
    -H "Content-Type: application/json" \
    -d @- << EOF
{"query" : "mutation {
  s3ConfigureArchiving(
    repositoryName: \"humio\",
    bucket: \"pale-1\",
    region: \"us-west-1\",
    format: RAW,
    tagOrderInName: [\"admin\", \"other\"]
  )
  { result }
}"
}
EOF

Mac OS or Linux (curl) One-line

shell

curl -v -X POST $YOUR_LOGSCALE_URL/graphql \
    -H "Authorization: Bearer $TOKEN" \
    -H "Content-Type: application/json" \
    -d @- << EOF
{"query" : "mutation {
  s3ConfigureArchiving(
    repositoryName: \"humio\",
    bucket: \"pale-1\",
    region: \"us-west-1\",
    format: RAW,
    tagOrderInName: [\"admin\", \"other\"]
  )
  { result }
}"
}
EOF

Windows Cmd and curl

shell

curl -v -X POST $YOUR_LOGSCALE_URL/graphql ^
    -H "Authorization: Bearer $TOKEN" ^
    -H "Content-Type: application/json" ^
    -d @'{"query" : "mutation { ^
  s3ConfigureArchiving( ^
    repositoryName: \"humio\", ^
    bucket: \"pale-1\", ^
    region: \"us-west-1\", ^
    format: RAW, ^
    tagOrderInName: [\"admin\", \"other\"] ^
  ) ^
  { result } ^
}" ^
} '

Windows Powershell and curl

powershell

curl.exe -X POST 
    -H "Authorization: Bearer $TOKEN"
    -H "Content-Type: application/json"
    -d '{"query" : "mutation {
  s3ConfigureArchiving(
    repositoryName: \"humio\",
    bucket: \"pale-1\",
    region: \"us-west-1\",
    format: RAW,
    tagOrderInName: [\"admin\", \"other\"]
  )
  { result }
}"
}'
    "$YOUR_LOGSCALE_URL/graphql"

Perl

perl

#!/usr/bin/perl

use HTTP::Request;
use LWP;

my $TOKEN = "TOKEN";

my $uri = '$YOUR_LOGSCALE_URL/graphql';

my $query = "mutation {
  s3ConfigureArchiving(
    repositoryName: \"humio\",
    bucket: \"pale-1\",
    region: \"us-west-1\",
    format: RAW,
    tagOrderInName: [\"admin\", \"other\"]
  )
  { result }
}";
$query =~ s/\n/ /g;
my $json = sprintf('{"query" : "%s"}',$query);
my $req = HTTP::Request->new("POST", $uri );

$req->header("Authorization" => "Bearer $TOKEN");
$req->header("Content-Type" => "application/json");

$req->content( $json );

my $lwp = LWP::UserAgent->new;

my $result = $lwp->request( $req );

print $result->{"_content"},"\n";

Python

python

#! /usr/local/bin/python3

import requests

url = '$YOUR_LOGSCALE_URL/graphql'
mydata = r'''{"query" : "mutation {
  s3ConfigureArchiving(
    repositoryName: \"humio\",
    bucket: \"pale-1\",
    region: \"us-west-1\",
    format: RAW,
    tagOrderInName: [\"admin\", \"other\"]
  )
  { result }
}"
}'''

resp = requests.post(url,
                     data = mydata,
                     headers = {
   "Authorization" : "Bearer $TOKEN",
   "Content-Type" : "application/json"
}
)

print(resp.text)

Node.js

javascript

const https = require('https');

const data = JSON.stringify(
    {"query" : "mutation {
  s3ConfigureArchiving(
    repositoryName: \"humio\",
    bucket: \"pale-1\",
    region: \"us-west-1\",
    format: RAW,
    tagOrderInName: [\"admin\", \"other\"]
  )
  { result }
}"
}
);


const options = {
  hostname: '$YOUR_LOGSCALE_URL',
  path: 'graphql',
  port: 443,
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': data.length,
    Authorization: 'BEARER ' + process.env.TOKEN,
    'User-Agent': 'Node',
  },
};

const req = https.request(options, (res) => {
  let data = '';
  console.log(`statusCode: ${res.statusCode}`);

  res.on('data', (d) => {
    data += d;
  });
  res.on('end', () => {
    console.log(JSON.parse(data).data);
  });
});

req.on('error', (error) => {
  console.error(error);
});

req.write(data);
req.end();

Example Responses

Success (HTTP Response Code 200 OK)

json

{
  "data": {
    "s3ConfigureArchiving": {
      "result": true
    }
  }
}

Given Datatype

For the input, you'll have to specify the name of the repository, the AWS region, and the S3 bucket and archiving format to use (see second table below). You may also give the start and end dates for archiving. See the table below for these parameters and others.

Table: Input Using Standard Datatypes

Parameter	Type	Required	Description
bucket	string	yes	The S3 bucket to use.
endAtDateTime	datetime		The date and time when archiving ends.
region	string	yes	The Amazon AWS region.
repositoryName	string	yes	The name of the repository.
roleArn	string		The ARN of the role to be assumed.
startFromDateTime	datetime		The date and time when archiving starts.
tagOrderInName	[string]		A list of tags for ordering.

For this datatype, you'll have to indicate the format to store archived segments in Amazon's AWS S3.

Table: S3ArchivingFormat

Parameter	Stability	Description
Some arguments may be required, as indicated in the Required column. For return datatypes, this indicates that you must specify which fields you want returned in the results.
Table last updated: May 9, 2025
NDJSON	`Short-Term`	The format for archival storage in AWS S3 is newline delimited JSON.
RAW	`Short-Term`	The format for archival storage of segments in AWS S3 is raw.

Returned Datatype

For this datatype, the only result is whether the mutation was successful or not. The table below describes this:

Table: BooleanResultType

Parameter	Type	Required	Stability	Description
Some arguments may be required, as indicated in the Required column. For return datatypes, this indicates that you must specify which fields you want returned in the results.
Table last updated: Sep 24, 2024
result	boolean	yes	`Long-Term`	Whether the mutation was performed successfully.

Versions of this Page

GraphQL Mutations

GraphQL API Stability

GraphQL Queries

GraphQL Datatypes