Simple Log Service:Início rápido para o SDK do Android

Configurar parâmetros dinamicamente

O SDK do Android permite configurar dinamicamente parâmetros como Endpoint, ProjectName, Logstore e AccessKey.

• Configure dinamicamente o Endpoint, ProjectName e logstore.

  // Configure parameters such as Endpoint, ProjectName, and logstore together or separately.
  // Update the endpoint.
  config.setEndpoint("your new-endpoint");
  // Update the project name.
  config.setProject("your new-project");
  // Update the logstore name.
  config.setLogstore("your new-logstore");

• Configure o AccessKey dinamicamente.

  Ao configurar o AccessKey dinamicamente, recomendamos usá-lo com o LogProducerCallback.

  // If you have initialized LogProducerCallback when you initialized LogProducerClient, ignore the following code.
  final LogProducerCallback callback = new LogProducerCallback() {
      @Override
      public void onCall(int resultCode, String reqId, String errorMessage, int logBytes, int compressedBytes) {
          // resultCode: the status code. For more information, see Error codes.
          // reqId: the request ID. This parameter is deprecated.
          // errorMessage: the failure information.
          // logBytes: the original log size in bytes.
          // compressedBytes: the compressed log size in bytes.
  
          final LogProducerResult result = LogProducerResult.fromInt(resultCode);
          if (LogProducerResult.LOG_PRODUCER_SEND_UNAUTHORIZED == result || LogProducerResult.LOG_PRODUCER_PARAMETERS_INVALID == result) {
              // You need to update the AccessKey or the initialization parameters of the SDK.
              requestAccessKey();
          }
      }
  };
  
  // To follow the success or failure status of log sending, you must pass a callback as the second parameter.
  client = new LogProducerClient(config, callback);
  
  // Request the AccessKey information.
  private void requestAccessKey() {
      // We recommend that you use the mobile log direct upload service to configure the AccessKey information.
      // ...
  
      // After you obtain the AccessKey information, update it.
      updateAccessKey(accessKeyId, accessKeySecret, securityToken);
  }
  
  // Update the AccessKey information.
  private void updateAccessKey(String accessKeyId, String accessKeySecret, String securityToken) {
      // The AccessKey obtained from STS contains a securityToken. You must update the AccessKey in the following way.
      if (null != securityToken && !"".equals(securityToken)) {
          config.resetSecurityToken(accessKeyId, accessKeySecret, securityToken);
      } else {
          // If the AccessKey is not obtained from STS, update the AccessKey in the following way.
          config.setAccessKeyId(accessKeyId);
          config.setAccessKeySecret(accessKeySecret);
      }
  }

• Defina dinamicamente source, topic e tag.

  Importante

  Não é possível definir source, topic ou tag para um tipo específico de log. Esses parâmetros se aplicam a todos os logs pendentes de envio para o SLS. Se você usar source, topic e tag para rastrear tipos específicos de log, os resultados podem ser imprecisos. Recomendamos adicionar campos durante a geração do log para identificar o tipo.

  // Set the log source.
  config.setSource("your new-source");
  // Set the log topic.
  config.setTopic("your new-topic");
  // Set the tag information. This tag is added to each log.
  config.addTag("test", "your new-tag");

Upload retomável

O SDK do Android oferece suporte a upload retomável. Ao ativar esse recurso, os logs adicionados pelo método addLog são salvos em um arquivo binlog local. Os dados locais são excluídos apenas após o envio bem-sucedido dos logs, garantindo a entrega pelo menos uma vez.

Adicione o código a seguir durante a inicialização do SDK para ativar o upload retomável.

private void initProducer() {
    // 1: enables the resumable upload feature. 0: disables the feature. Default value: 0.
    config.setPersistent(1);
    // The name of the persistence file. Make sure that the folder where the file is located has been created.
    final String persistentFilePath = getFilesDir() + File.separator + "log_data";
    config.setPersistentFilePath(persistentFilePath);
    // The number of scrolling persistence files. We recommend that you set this parameter to 10.
    config.setPersistentMaxFileCount(10);
    // The size of each persistence file. Unit: bytes. The format is N*1024*1024. We recommend that you set N to a value from 1 to 10.
    config.setPersistentMaxFileSize(N*1024*1024);
    // The maximum number of logs that can be cached locally. We recommend that you do not set this parameter to a value greater than 1,048,576. Default value: 65,536.
    config.setPersistentMaxLogCount(65536);
}

Regras de obfuscação

-keep class com.aliyun.sls.android.producer.** { *; }
-keep interface com.aliyun.sls.android.producer.** { *; }

Permissões do Android

<uses-permission android:name="android.permission.INTERNET" />

Por que existem logs duplicados?

O SDK do Android envia logs de forma assíncrona. Devido às condições de rede, um log pode falhar no envio e ser reenviado. O SDK considera uma operação de envio bem-sucedida apenas quando recebe um código de status 200, portanto alguns logs podem ser duplicados. Recomendamos usar consultas SQL e instruções de análise para deduplicar logs.

Se a taxa de duplicação de logs for alta, verifique se há problemas na inicialização do SDK. Causas comuns e soluções:

• Configuração incorreta de upload retomável

  Se o upload retomável estiver configurado incorretamente, confirme se o caminho de arquivo passado ao método setPersistentFilePath é globalmente exclusivo.

• Inicialização repetida do SDK

  • Uma causa comum é a implementação incorreta do padrão singleton para inicialização do SDK. Recomendamos a seguinte abordagem.

    public class AliyunLogHelper {
        private LogProducerConfig config;
        private LogProducerClient client;
    
        private static class Holder {
            private static final AliyunLogHelper INSTANCE = new AliyunLogHelper();
        }
    
        public static AliyunLogHelper getInstance() {
            return Holder.INSTANCE;
        }
    
        private AliyunLogHelper() {
            initProducer();
        }
    
        private void initProducer() {
            // Replace the following code with your initialization code.
            try {
                config = new LogProducerConfig();
                client = new LogProducerClient(config);
            } catch (LogProducerException e) {
                e.printStackTrace();
            }
        }
    
        public void addLog(Log log) {
            if (null == client) {
                return;
            }
    
            client.addLog(log);
        }
    }

  • Outra causa é o uso de vários processos. Inicialize o SDK apenas no processo principal. Se você inicializar o SDK em processos diferentes, defina um valor exclusivo para setPersistentFilePath em cada processo.

• Otimização de configuração para ambientes de rede instável

  Se o aplicativo for executado em um ambiente de rede instável, otimize os parâmetros de configuração do SDK conforme mostrado no exemplo a seguir.

  // Initialize the SDK.
  private void initProducer() {
      // Adjust the HTTP connection and sending timeout periods to reduce the log duplication rate.
      // Adjust the specific timeout periods as needed.
      config.setConnectTimeoutSec(20);
      config.setSendTimeoutSec(20);
    
      // Other initialization parameters.
      // ...
  }

O que fazer se houver logs ausentes?

O envio de logs é assíncrono. Se o aplicativo for fechado antes que os logs sejam enviados, logs não enviados podem ser perdidos. Recomendamos ativar o recurso de upload retomável. Para obter mais informações, consulte Resumable upload.

O que fazer se houver atraso no reporte de logs?

O SDK envia logs de forma assíncrona. Os logs podem não ser enviados imediatamente devido a condições de rede ou cenários específicos do aplicativo. Atrasos em um pequeno número de dispositivos são normais. Se os atrasos forem generalizados, verifique os seguintes códigos de erro.

O SDK do Android suporta pré-resolução de DNS e políticas de cache?

Use o SDK do Android, o SDK HTTPDNS e o OkHttp para implementar pré-resolução de DNS e políticas de cache.

1. Implemente uma interface DNS personalizada.

   /**
     * Implement a custom DNS parsing service based on the OkHttp Dns interface for your reference.
     */
   public class OkHttpDns implements Dns {
     private Context mContext;
   
     public OkHttpDns(Context context) {
       mContext = context;
     }
   
     @Override
     public List<InetAddress> lookup(String host) throws UnknownHostException {
       // !!Note!! 
       // Replace accountId with the value that you obtained from the HTTPDNS service. For more information, see the HTTPDNS documentation.
       HTTPDNSResult httpdnsResult = HttpDns.getService(mContext, accountId)
         .getHttpDnsResultForHostSync(host, RequestIpType.both);
       List<InetAddress> inetAddresses = new ArrayList<>();
       InetAddress address;
       try {
         if (httpdnsResult.getIps() != null) {
           // Process IPv4 addresses.
           for (String ipv4 : httpdnsResult.getIps()) {
             address = InetAddress.getByName(ipv4);
             inetAddresses.add(address);
           }
         }
   
         if (httpdnsResult.getIpv6s() != null) {
           // Process IPv6 addresses.
           for (String ipv6 : httpdnsResult.getIpv6s()) {
             address = InetAddress.getByName(ipv6);
             inetAddresses.add(address);
           }
         }
       } catch (UnknownHostException e) {
   
       }
   
       if (!inetAddresses.isEmpty()) {
         return inetAddresses;
       }
   
       return okhttp3.Dns.SYSTEM.lookup(host);
     }
   }

2. Implemente uma NetworkInterface personalizada.

   /**
      * Implement the NetworkInterface of the SLS SDK based on OkHttp for your reference.
      */
   private static class OkHttpNetworkInterface implements LogProducerHttpTool.NetworkInterface {
   
     private OkHttpClient client;
   
     public OkHttpNetworkInterface(Context context) {
       client = new OkHttpClient.Builder()
         .connectTimeout(30, TimeUnit.SECONDS)
         .readTimeout(30, TimeUnit.SECONDS)
         .writeTimeout(30, TimeUnit.SECONDS)
         .dns(new OkHttpDns(context))
         .build();
     }
   
     @Override
     public NetworkResponse send(String urlString, String method, String[] header, byte[] body) {
       // We recommend that you first call the original implementation of the SDK and then report logs using OkHttp when log reporting fails.
       LogHttpResponse logHttpResponse = LogProducerHttpTool.android_http_post(urlString, method, header, body);
       if (logHttpResponse.getStatusCode() != -1) {
         NetworkResponse response = new NetworkResponse();
         response.statusCode = logHttpResponse.getStatusCode();
         response.errorMessage = logHttpResponse.getErrorMessage();
         return response;
       }
   
       // Report logs using OkHttp.
       Request.Builder builder = new Request.Builder();
       builder.url(urlString);
       builder.post(RequestBody.create(body));
   
       for (int i = 0; i < header.length; i += 2) {
         builder.addHeader(header[i], header[i + 1]);
       }
   
       // Regardless of whether the request is successful, you must return a NetworkResponse. Otherwise, the SDK may not run as expected.
       try (okhttp3.Response response = client.newCall(builder.build()).execute()) {
         NetworkResponse httpResponse = new NetworkResponse();
         httpResponse.statusCode = response.code();
         httpResponse.headers = response.headers().toMultimap();
         httpResponse.errorMessage = response.message();
   
         return httpResponse;
       } catch (IOException e) {
         NetworkResponse httpResponse = new NetworkResponse();
         httpResponse.statusCode = -1;
         httpResponse.headers = null;
         httpResponse.errorMessage = e.getLocalizedMessage();
   
         return httpResponse;
       }
     }
   
   }
   

3. Inicialize o SDK do SLS.

   public class AliyunSLS {
     private void initSLS(Context context) {
       // Set a custom NetworkInterface for the SLS SDK.
       // !!!Note!!!
       // This setting takes effect for all SLS SDK instances.
       LogProducerHttpTool.setNetworkInterface(new OkHttpNetworkInterface(context));
   
       // Initialize the SLS SDK.
       initProducer();
     }
   
     private void initProducer() {
       // Implement the initialization of LogProducerConfig and LogProducerClient here.
       // ...
     }
   }