s3ConfigureArchiving()

Summary

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 Input Parameters section for details.

For the results, you'll receive confirmation if successful. See the Returned Values 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
    }
  }
}

Input Parameters

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 Parameters & Datatypes

Parameter	Type	Required	Description
This table contains all input parameters for this mutation. Since one of the parameters uses a special datatype, an additional table is included below with its parameters.
bucket	string	yes	The S3 bucket to use.
endAtDateTime	datetime		The date and time when archiving ends.
format	S3ArchivingFormat	yes	The format to store archived segments in AWS S3. See the next table.
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 Enum Datatype

Parameter	Stability	Description
Some input parameters may be required, as indicated in the Required column. For return values, this indicates that you are assured a value if the field is requested for 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 Values

For the results, the only returned value indicates whether the mutation was successful or not. The table below describes this:

Table: BooleanResultType Datatype

Parameter	Type	Required	Stability	Description
Some input parameters may be required, as indicated in the Required column. For return values, this indicates that you are assured a value if the field is requested for 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

GraphQL API Stability

GraphQL Queries

GraphQL Datatypes