using Auth0.ManagementApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new ManagementApiClient(
            token: "<token>",
            clientOptions: new ClientOptions { BaseUrl = "https://{YOUR_DOMAIN}/api/v2" }
        );

        await client.LogStreams.CreateAsync(
            new CreateLogStreamHttpRequestBody {
                Type = LogStreamHttpEnum.Http,
                Sink = new LogStreamHttpSink {
                    HttpEndpoint = "httpEndpoint"
                }
            }
        );
    }

}

package example

import (
    context "context"

    management "github.com/auth0/go-auth0/v3/management"
    client "github.com/auth0/go-auth0/v3/management/client"
    option "github.com/auth0/go-auth0/v3/management/option"
)

func do() {
    mgmt, err := client.New(
        "{YOUR_DOMAIN}",
        option.WithToken(
            "<token>",
        ),
    )
    if err != nil {
        return
    }
    request := &management.CreateLogStreamRequestContent{
        CreateLogStreamHttpRequestBody: &management.CreateLogStreamHttpRequestBody{
            Type: management.LogStreamHttpEnum(
                "http",
            ),
            Sink: &management.LogStreamHttpSink{
                HttpEndpoint: "httpEndpoint",
            },
        },
    }
    mgmt.LogStreams.Create(
        context.TODO(),
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.types.CreateLogStreamHttpRequestBody;
import com.auth0.client.mgmt.types.CreateLogStreamRequestContent;
import com.auth0.client.mgmt.types.LogStreamHttpEnum;
import com.auth0.client.mgmt.types.LogStreamHttpSink;

public class Example {
    public static void main(String[] args) {
        ManagementApi client = ManagementApi
            .builder()
            .domain("{YOUR_DOMAIN}")
            .token("<token>")
            .build();

        client.logStreams().create(
            CreateLogStreamRequestContent.of(
                CreateLogStreamHttpRequestBody
                    .builder()
                    .type(LogStreamHttpEnum.HTTP)
                    .sink(
                        LogStreamHttpSink
                            .builder()
                            .httpEndpoint("httpEndpoint")
                            .build()
                    )
                    .build()
            )
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\Types\CreateLogStreamHttpRequestBody;
use Auth0\SDK\API\Management\Types\LogStreamHttpEnum;
use Auth0\SDK\API\Management\Types\LogStreamHttpSink;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->logStreams->create(
    new CreateLogStreamHttpRequestBody([
        'type' => LogStreamHttpEnum::Http->value,
        'sink' => new LogStreamHttpSink([
            'httpEndpoint' => 'httpEndpoint',
        ]),
    ]),
);

from auth0.management import ManagementClient, CreateLogStreamHttpRequestBody, LogStreamHttpSink

client = ManagementClient(
    domain="{YOUR_DOMAIN}",
    token="<token>",
)

client.log_streams.create(
    request=CreateLogStreamHttpRequestBody(
        type="http",
        sink=LogStreamHttpSink(
            http_endpoint="httpEndpoint",
        ),
    ),
)

require "auth0"

client = Auth0::Management.new(token: "<token>", base_url: "https://{YOUR_DOMAIN}/api/v2")

client.log_streams.create(
  type: "http",
  sink: {
    http_endpoint: "httpEndpoint"
  }
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.logStreams.create({
        type: "http",
        sink: {
            httpEndpoint: "httpEndpoint",
        },
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.logStreams.create({
        type: "http",
        sink: {
            httpEndpoint: "httpEndpoint",
        },
    });
}
main();

curl --request POST \
  --url https://{tenantDomain}/api/v2/log-streams \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "sink": {
    "httpEndpoint": "<string>",
    "httpAuthorization": "<string>",
    "httpContentType": "<string>",
    "httpCustomHeaders": [
      {
        "header": "<string>",
        "value": "<string>"
      }
    ]
  },
  "type": "http",
  "filters": [
    {
      "type": "category"
    }
  ],
  "isPriority": true,
  "name": "<string>",
  "startFrom": "2021-03-01T19:57:29.532Z"
}
'

{
  "filters": [
    {
      "type": "category"
    }
  ],
  "id": "<string>",
  "isPriority": true,
  "name": "<string>",
  "pii_config": {
    "log_fields": [],
    "algorithm": "xxhash"
  },
  "sink": {
    "httpEndpoint": "<string>",
    "httpAuthorization": "<string>",
    "httpContentType": "<string>",
    "httpCustomHeaders": [
      {
        "header": "<string>",
        "value": "<string>"
      }
    ]
  },
  "type": "http"
}

Publier des flux de journaux

Créez un flux de journaux.

Types de flux de journaux

Le type du flux de journaux à créer détermine les propriétés requises dans le payload sink.

Flux HTTP

Pour un flux http, les propriétés de sink sont indiquées dans le payload ci-dessous.

Requête :

{
  "name": "string",
  "type": "http",
  "sink": {
    "httpEndpoint": "string",
    "httpContentType": "string",
    "httpContentFormat": "JSONLINES|JSONARRAY",
    "httpAuthorization": "string"
  }
}

Réponse :

{
  "id": "string",
  "name": "string",
  "type": "http",
  "status": "active",
  "sink": {
    "httpEndpoint": "string",
    "httpContentType": "string",
    "httpContentFormat": "JSONLINES|JSONARRAY",
    "httpAuthorization": "string"
  }
}

Flux Amazon EventBridge

Pour un flux eventbridge, les propriétés de sink sont indiquées dans le payload ci-dessous.

Requête :

{
  "name": "string",
  "type": "eventbridge",
  "sink": {
    "awsRegion": "string",
    "awsAccountId": "string"
  }
}

La réponse comprendra un champ supplémentaire, awsPartnerEventSource, dans sink :

Réponse :

{
  "id": "string",
  "name": "string",
  "type": "eventbridge",
  "status": "active",
  "sink": {
    "awsAccountId": "string",
    "awsRegion": "string",
    "awsPartnerEventSource": "string"
  }
}

Flux Azure Event Grid

Pour un flux Azure Event Grid, les propriétés de sink sont indiquées dans le payload ci-dessous.

Requête :

{
  "name": "string",
  "type": "eventgrid",
  "sink": {
    "azureSubscriptionId": "string",
    "azureResourceGroup": "string",
    "azureRegion": "string"
  }
}

Réponse :

{
  "id": "string",
  "name": "string",
  "type": "http",
  "status": "active",
  "sink": {
    "azureSubscriptionId": "string",
    "azureResourceGroup": "string",
    "azureRegion": "string",
    "azurePartnerTopic": "string"
  }
}

Flux Datadog

Pour un flux Datadog, les propriétés de sink sont indiquées dans le payload ci-dessous.

Requête :

{
  "name": "string",
  "type": "datadog",
  "sink": {
    "datadogRegion": "string",
    "datadogApiKey": "string"
  }
}

Réponse :

{
  "id": "string",
  "name": "string",
  "type": "datadog",
  "status": "active",
  "sink": {
    "datadogRegion": "string",
    "datadogApiKey": "string"
  }
}

Flux Splunk

Pour un flux Splunk, les propriétés de sink sont indiquées dans le payload ci-dessous.

Requête :

{
  "name": "string",
  "type": "splunk",
  "sink": {
    "splunkDomain": "string",
    "splunkToken": "string",
    "splunkPort": "string",
    "splunkSecure": "boolean"
  }
}

Réponse :

{
  "id": "string",
  "name": "string",
  "type": "splunk",
  "status": "active",
  "sink": {
    "splunkDomain": "string",
    "splunkToken": "string",
    "splunkPort": "string",
    "splunkSecure": "boolean"
  }
}

Flux Sumo Logic

Pour un flux Sumo Logic, les propriétés de sink sont indiquées dans le payload ci-dessous.

Requête :

{
  "name": "string",
  "type": "sumo",
  "sink": {
    "sumoSourceAddress": "string"
  }
}

Réponse :

{
  "id": "string",
  "name": "string",
  "type": "sumo",
  "status": "active",
  "sink": {
    "sumoSourceAddress": "string"
  }
}

POST

https://{tenantDomain}/api/v2

log-streams

using Auth0.ManagementApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new ManagementApiClient(
            token: "<token>",
            clientOptions: new ClientOptions { BaseUrl = "https://{YOUR_DOMAIN}/api/v2" }
        );

        await client.LogStreams.CreateAsync(
            new CreateLogStreamHttpRequestBody {
                Type = LogStreamHttpEnum.Http,
                Sink = new LogStreamHttpSink {
                    HttpEndpoint = "httpEndpoint"
                }
            }
        );
    }

}

package example

import (
    context "context"

    management "github.com/auth0/go-auth0/v3/management"
    client "github.com/auth0/go-auth0/v3/management/client"
    option "github.com/auth0/go-auth0/v3/management/option"
)

func do() {
    mgmt, err := client.New(
        "{YOUR_DOMAIN}",
        option.WithToken(
            "<token>",
        ),
    )
    if err != nil {
        return
    }
    request := &management.CreateLogStreamRequestContent{
        CreateLogStreamHttpRequestBody: &management.CreateLogStreamHttpRequestBody{
            Type: management.LogStreamHttpEnum(
                "http",
            ),
            Sink: &management.LogStreamHttpSink{
                HttpEndpoint: "httpEndpoint",
            },
        },
    }
    mgmt.LogStreams.Create(
        context.TODO(),
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.types.CreateLogStreamHttpRequestBody;
import com.auth0.client.mgmt.types.CreateLogStreamRequestContent;
import com.auth0.client.mgmt.types.LogStreamHttpEnum;
import com.auth0.client.mgmt.types.LogStreamHttpSink;

public class Example {
    public static void main(String[] args) {
        ManagementApi client = ManagementApi
            .builder()
            .domain("{YOUR_DOMAIN}")
            .token("<token>")
            .build();

        client.logStreams().create(
            CreateLogStreamRequestContent.of(
                CreateLogStreamHttpRequestBody
                    .builder()
                    .type(LogStreamHttpEnum.HTTP)
                    .sink(
                        LogStreamHttpSink
                            .builder()
                            .httpEndpoint("httpEndpoint")
                            .build()
                    )
                    .build()
            )
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\Types\CreateLogStreamHttpRequestBody;
use Auth0\SDK\API\Management\Types\LogStreamHttpEnum;
use Auth0\SDK\API\Management\Types\LogStreamHttpSink;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->logStreams->create(
    new CreateLogStreamHttpRequestBody([
        'type' => LogStreamHttpEnum::Http->value,
        'sink' => new LogStreamHttpSink([
            'httpEndpoint' => 'httpEndpoint',
        ]),
    ]),
);

from auth0.management import ManagementClient, CreateLogStreamHttpRequestBody, LogStreamHttpSink

client = ManagementClient(
    domain="{YOUR_DOMAIN}",
    token="<token>",
)

client.log_streams.create(
    request=CreateLogStreamHttpRequestBody(
        type="http",
        sink=LogStreamHttpSink(
            http_endpoint="httpEndpoint",
        ),
    ),
)

require "auth0"

client = Auth0::Management.new(token: "<token>", base_url: "https://{YOUR_DOMAIN}/api/v2")

client.log_streams.create(
  type: "http",
  sink: {
    http_endpoint: "httpEndpoint"
  }
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.logStreams.create({
        type: "http",
        sink: {
            httpEndpoint: "httpEndpoint",
        },
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.logStreams.create({
        type: "http",
        sink: {
            httpEndpoint: "httpEndpoint",
        },
    });
}
main();

curl --request POST \
  --url https://{tenantDomain}/api/v2/log-streams \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "sink": {
    "httpEndpoint": "<string>",
    "httpAuthorization": "<string>",
    "httpContentType": "<string>",
    "httpCustomHeaders": [
      {
        "header": "<string>",
        "value": "<string>"
      }
    ]
  },
  "type": "http",
  "filters": [
    {
      "type": "category"
    }
  ],
  "isPriority": true,
  "name": "<string>",
  "startFrom": "2021-03-01T19:57:29.532Z"
}
'

{
  "filters": [
    {
      "type": "category"
    }
  ],
  "id": "<string>",
  "isPriority": true,
  "name": "<string>",
  "pii_config": {
    "log_fields": [],
    "algorithm": "xxhash"
  },
  "sink": {
    "httpEndpoint": "<string>",
    "httpAuthorization": "<string>",
    "httpContentType": "<string>",
    "httpCustomHeaders": [
      {
        "header": "<string>",
        "value": "<string>"
      }
    ]
  },
  "type": "http"
}

Autorisations

Authorization

string

header

requis

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Corps

sink

object

requis

Show child attributes

type

enum<string>

requis

Options disponibles:

http

filters

object[]

Seuls les événements de journal correspondant à ces filtres seront transmis par le flux. Si ces filtres sont omis ou vides, tous les événements seront transmis.

Show child attributes

isPriority

boolean

Vrai pour les flux de journaux prioritaires, faux pour les flux non prioritaires

name

string

nom du flux de journaux

pii_config

object

Show child attributes

startFrom

string

défaut:2021-03-01T19:57:29.532Z

Date et heure facultatives (ISO 8601) à partir desquelles commencer la diffusion des journaux

Réponse

Flux de journaux créé

filters

object[]

Seuls les événements de journal correspondant à ces filtres seront transmis par le flux. Si ces filtres sont omis ou vides, tous les événements seront transmis.

Show child attributes

string<log-stream-id>

ID du flux de journaux

isPriority

boolean

Vrai pour les flux de journaux prioritaires, faux sinon

name

string

nom du flux de journaux

pii_config

object

Show child attributes

sink

object

Show child attributes

status

enum<string>

L’état du flux de journaux. Valeurs possibles : active, paused, suspended

Options disponibles:

active,

paused,

suspended

type

enum<string>

Options disponibles:

http