🎯API Stability
Long-TermThis API is stable and will remain supported across versions with minimal breaking changes.

Summary

The updateFieldAliasSchema() mutation updates an existing field alias schema. Field alias schemas map field names to alternate names across views, normalizing data from different sources. Use this mutation after createFieldAliasSchema() when you need to change a schema's name, field definitions, or alias mappings. Each optional argument overrides the corresponding property; omit an argument to leave that property unchanged.

Syntax

graphql
updateFieldAliasSchema(
      input: UpdateFieldAliasSchemaInput!
   ): FieldAliasSchema!

The mutation takes a single required argument, input, of type UpdateFieldAliasSchemaInput!. The input requires the schema id; all other fields are optional. Provide name, fields, or aliasMappings to override those properties. The mutation returns the updated FieldAliasSchema! object, which is non-null.

Input parameters

The id argument identifies the schema to update. Supply it using the ID returned by fieldAliasSchemas(). The remaining arguments — name, fields, and aliasMappings — are optional. Each one fully replaces the corresponding property when provided; omitting it leaves the existing value unchanged.

Table: UpdateFieldAliasSchemaInput Input Datatype

ParameterTypeRequiredDefaultStabilityAvailabilityDescription
aliasMappingsAliasMappingInputyes Long-Term The alias mappings on the schema. This overrides the existing alias mappings. If not supplied, the alias mapping will be unchanged. See AliasMappingInput.
fieldsSchemaFieldInputyes Long-Term The fields of the schema. This overrides the existing fields. If not supplied, the fields will be unchanged. See SchemaFieldInput.
idStringyes Long-Term The unique identifier of the schema.
nameString  Long-Term The name of the schema. This will override the existing name. If not supplied, the name will be unchanged.

Example

Raw
graphql
mutation {
  updateFieldAliasSchema( input:
     { id: "abc123", 
       aliasMappings: [ 
             { name: "my-alias", 
               tags: [ {name: "#kind", value: "logs"}, 
                       {name: "#repo", value: "github"} ],
               aliases: [ { source: "some", alias: "thing" } ] } ]
     } 
  )
  { id }
}
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 {
  updateFieldAliasSchema( input:
     { id: \"abc123\", 
       aliasMappings: [ 
             { name: \"my-alias\", 
               tags: [ {name: \"#kind\", value: \"logs\"}, 
                       {name: \"#repo\", value: \"github\"} ],
               aliases: [ { source: \"some\", alias: \"thing\" } ] } ]
     } 
  )
  { id }
}"
}
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 {
  updateFieldAliasSchema( input:
     { id: \"abc123\", 
       aliasMappings: [ 
             { name: \"my-alias\", 
               tags: [ {name: \"#kind\", value: \"logs\"}, 
                       {name: \"#repo\", value: \"github\"} ],
               aliases: [ { source: \"some\", alias: \"thing\" } ] } ]
     } 
  )
  { id }
}"
}
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 { ^
  updateFieldAliasSchema( input: ^
     { id: \"abc123\",  ^
       aliasMappings: [  ^
             { name: \"my-alias\",  ^
               tags: [ {name: \"#kind\", value: \"logs\"},  ^
                       {name: \"#repo\", value: \"github\"} ], ^
               aliases: [ { source: \"some\", alias: \"thing\" } ] } ] ^
     }  ^
  ) ^
  { id } ^
}" ^
} '
Windows Powershell and curl
powershell
curl.exe -X POST 
    -H "Authorization: Bearer $TOKEN"
    -H "Content-Type: application/json"
    -d '{"query" : "mutation {
  updateFieldAliasSchema( input:
     { id: \"abc123\", 
       aliasMappings: [ 
             { name: \"my-alias\", 
               tags: [ {name: \"#kind\", value: \"logs\"}, 
                       {name: \"#repo\", value: \"github\"} ],
               aliases: [ { source: \"some\", alias: \"thing\" } ] } ]
     } 
  )
  { id }
}"
}'
    "$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 {
  updateFieldAliasSchema( input:
     { id: \"abc123\", 
       aliasMappings: [ 
             { name: \"my-alias\", 
               tags: [ {name: \"#kind\", value: \"logs\"}, 
                       {name: \"#repo\", value: \"github\"} ],
               aliases: [ { source: \"some\", alias: \"thing\" } ] } ]
     } 
  )
  { id }
}";
$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 {
  updateFieldAliasSchema( input:
     { id: \"abc123\", 
       aliasMappings: [ 
             { name: \"my-alias\", 
               tags: [ {name: \"#kind\", value: \"logs\"}, 
                       {name: \"#repo\", value: \"github\"} ],
               aliases: [ { source: \"some\", alias: \"thing\" } ] } ]
     } 
  )
  { id }
}"
}'''

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 {
  updateFieldAliasSchema( input:
     { id: \"abc123\", 
       aliasMappings: [ 
             { name: \"my-alias\", 
               tags: [ {name: \"#kind\", value: \"logs\"}, 
                       {name: \"#repo\", value: \"github\"} ],
               aliases: [ { source: \"some\", alias: \"thing\" } ] } ]
     } 
  )
  { id }
}"
}
);


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": {
    "updateFieldAliasSchema": {
      "id": "abc123"
    }
  }
}

Returned values

The mutation returns the updated FieldAliasSchema! object, which is non-null. The returned object includes the schema's unique identifier, its name, the list of defined fields and their descriptions, and the alias mappings that associate field names with alternate names across views.

Table: FieldAliasSchema Datatype

ParameterTypeRequiredDefaultStabilityAvailabilityDescription
fieldsSchemaFieldyes Long-Term The schema fields. See SchemaField.
idStringyes Long-Term The unique identifier of the field alias schema.
instancesAliasMappingyes Long-Term The instances used. See AliasMapping.
nameStringyes Long-Term The name of the schema.
versionStringyes Long-Term The version.
yamlTemplateYAMLyes Long-Term A yaml template. YAML is a scalar.