Simple Log Service:Get started with the iOS SDK

Dynamically configure parameters

The iOS SDK supports dynamic configuration of parameters such as ProjectName, Logstore, Endpoint, and AccessKey. For more information about how to obtain an endpoint, see Endpoints. For more information about how to obtain an AccessKey pair, see AccessKey pair.

• Dynamically configure Endpoint, ProjectName, and Logstore.

  // You can configure the Endpoint, ProjectName, and Logstore parameters independently or together.
  // Update the endpoint.
  [_config setEndpoint:@"your new-endpoint"];
  // Update ProjectName.
  [_config setProject:@"your new-project"];
  // Update the Logstore.
  [_config setLogstore:@"your new-logstore"];

• Dynamically configure an AccessKey pair.

  When you dynamically configure an AccessKey pair, we recommend that you use it with a callback function.

  // If you have initialized the callback function when you initialize LogProducerClient, you can ignore the following code.
  static void _on_log_send_done(const char * config_name, log_producer_result result, size_t log_bytes, size_t compressed_bytes, const char * req_id, const char * message, const unsigned char * raw_buffer, void * userparams) {
      if (LOG_PRODUCER_SEND_UNAUTHORIZED == result || LOG_PRODUCER_PARAMETERS_INVALID) {
          [selfClzz requestAccessKey]; // A reference to the current class instance, captured for use within the C-style callback function.
      }
  }
  
  // If you want to check whether a log is sent, pass a callback function as the second parameter.
  _client = [[LogProducerClient alloc] initWithLogProducerConfig:_config callback:_on_log_send_done];
  
  // Request the AccessKey pair information.
  - (void) requestAccessKey {
      // We recommend that you first use the service for direct log transfer from mobile devices to configure the AccessKey pair information.
      // ...
  
      // After you obtain the AccessKey pair information, update the information.
      [self updateAccessKey:accessKeyId accessKeySecret:accessKeySecret securityToken:securityToken];
  }
  
  // Update the AccessKey pair information.
  - (void) updateAccessKey:(NSString *)accessKeyId accessKeySecret:(NSString *)accessKeySecret securityToken:(NSString *)securityToken {
      
      // If you obtain an AccessKey pair using STS, the AccessKey pair contains a security token. In this case, you must update the AccessKey pair in the following way.
      if (securityToken.length > 0) {
          if (accessKeyId.length > 0 && accessKeySecret.length > 0) {
              [_config ResetSecurityToken:accessKeyId
                          accessKeySecret:accessKeySecret
                            securityToken:securityToken
              ];
          }
      } else {
          // If you do not obtain an AccessKey pair using STS, update the AccessKey pair in the following way.
          if (accessKeyId.length > 0 && accessKeySecret.length > 0) {
              [_config setAccessKeyId: accessKeyId];
              [_config setAccessKeySecret: accessKeySecret];
          }
      }
  }

• Dynamically configure source, topic, and tag.

  Important

  These settings apply globally and affect all subsequent logs, including any logs currently in the retry buffer. If your business logic requires tracking specific log types with these parameters, this global behavior may lead to unexpected results. We recommend that you add a custom field to each log to identify its type.

  // Set the log topic.
  [_config SetTopic:@"your new-topic"];
  // Set the log source.
  [_config SetSource:@"your new-source"];
  // Set tags. The tags are attached to each log.
  [_config AddTag:@"test" value:@"your new-tag"];

Resumable upload

The iOS SDK supports resumable upload. When this feature is enabled, logs submitted using the addLog method are first persisted to a local binary log (binlog) file. The local data is deleted only after the logs are successfully sent. This ensures at-least-once semantics for log uploads.

To implement resumable upload, add the following code during SDK initialization.

- (void) initLogProducer {
    // A value of 1 enables resumable upload. A value of 0 disables this feature. Default value: 0.
    [_config SetPersistent:1];
    
    // The name of the persistence file. Make sure that the folder in which the file is stored is created.
    NSArray  *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *Path = [[paths lastObject] stringByAppendingString:@"/log.dat"];
    [_config SetPersistentFilePath:Path];
    // The number of persistent files that can be rolled over. We recommend that you set this parameter to 10.
    [_config SetPersistentMaxFileCount:10];
    // The size of each persistent file in bytes. The value is calculated using the formula: 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];
}

Why do duplicate logs exist?

The iOS SDK sends logs asynchronously. Due to network conditions, a log may fail to send and is then resent. The SDK considers a log successfully sent only when a status code of 200 is returned. This can result in duplicate logs. We recommend that you use SQL statements during query and analysis to remove duplicate data.

If you experience a high log duplication rate, check for errors in the SDK initialization. The following list describes common causes and their solutions.

• Incorrect configuration for resumable upload

  Check whether the file path provided to the SetPersistentFilePath method is globally unique.

• Repeated SDK initialization

  • A common cause of repeated SDK initialization is an incorrect implementation of the singleton instance or the failure to use a singleton pattern for SDK initialization. We recommend that you initialize the SDK as shown in the following example.

    // AliyunLogHelper.h
    @interface AliyunLogHelper : NSObject
    + (instancetype)sharedInstance;
    - (void) addLog:(Log *)log;
    @end
    
    
    // AliyunLogHelper.m
    @interface AliyunLogHelper ()
    @property(nonatomic, strong) LogProducerConfig *config;
    @property(nonatomic, strong) LogProducerClient *client;
    @end
    
    @implementation AliyunLogHelper
    
    + (instancetype)sharedInstance {
        static AliyunLogHelper *sharedInstance = nil;
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            sharedInstance = [[self alloc] init];
        });
        return sharedInstance;
    }
    
    - (instancetype)init {
        self = [super init];
        if (self) {
            [self initLogProducer];
        }
        return self;
    }
    
    - (void) initLogProducer {
        // Replace the following code with your initialization code.
        _config = [[LogProducerConfig alloc] initWithEndpoint:@""
                                                      project:@""
                                                     logstore:@""
                                                  accessKeyID:@""
                                              accessKeySecret:@""
                                                securityToken:@""
        ];
    
        _client = [[LogProducerClient alloc] initWithLogProducerConfig:_config callback:_on_log_send_done];
    }
    
    - (void) addLog:(Log *)log {
        if (nil == log) {
            return;
        }
    
        [_client AddLog:log];
    }
    
    @end

  • Another cause of repeated SDK initialization is the use of multiple processes. We recommend that you initialize the SDK only in the main process. If you must initialize the SDK in different processes, provide a unique value to SetPersistentFilePath for each process.

• Configuration optimization for weak network environments

  If your application is used in an environment with a weak network connection, we recommend that you optimize the SDK configuration parameters as shown in the following example.

  // Initialize the SDK.
  - (void) initProducer() {
      // Adjust the timeout periods for HTTP connections and sending to reduce the log duplication rate.
      // You can adjust the specific timeout periods as needed.
      [_config SetConnectTimeoutSec:20];
      [_config SetSendTimeoutSec:20];
    
      // Other initialization parameters.
      // ...
  }

What do I do if logs are lost?

Log sending is an asynchronous process. If the application closes before the logs are sent, the logs may be lost. We recommend that you enable resumable upload. For more information, see Resumable upload.

What do I do if log reporting is delayed?

The SDK sends logs asynchronously. Logs may not be sent immediately due to the network environment or specific application scenarios. If log sending is delayed on only a few devices, this is normal. Otherwise, troubleshoot the issue using the error codes in the following table.

Does the iOS SDK support DNS pre-resolution and cache policies?

Yes. The following example shows how to use the iOS SDK with the HTTPDNS SDK to implement DNS pre-resolution and cache policies.

Note: If the Simple Log Service endpoint uses an HTTPS domain name, you must refer to Solutions for HTTPS and SNI scenarios.

1. Implement a custom NSURLProtocol.

   #import <Foundation/Foundation.h>
   #import "HttpDnsNSURLProtocolImpl.h"
   #import <arpa/inet.h>
   #import <zlib.h>
   #import <objc/runtime.h>
   
   static NSString *const hasBeenInterceptedCustomLabelKey = @"HttpDnsHttpMessagePropertyKey";
   static NSString *const kAnchorAlreadyAdded = @"AnchorAlreadyAdded";
   
   @interface HttpDnsNSURLProtocolImpl () <NSStreamDelegate>
   
   @property (strong, readwrite, nonatomic) NSMutableURLRequest *curRequest;
   @property (strong, readwrite, nonatomic) NSRunLoop *curRunLoop;
   @property (strong, readwrite, nonatomic) NSInputStream *inputStream;
   @property (nonatomic, assign) BOOL responseIsHandle;
   @property (assign, nonatomic) z_stream gzipStream;
   
   @end
   
   @implementation HttpDnsNSURLProtocolImpl
   
   - (instancetype)initWithRequest:(NSURLRequest *)request cachedResponse:(nullable NSCachedURLResponse *)cachedResponse client:(nullable id <NSURLProtocolClient>)client {
     self = [super initWithRequest:request cachedResponse:cachedResponse client:client];
     if (self) {
       _gzipStream.zalloc = Z_NULL;
       _gzipStream.zfree = Z_NULL;
       if (inflateInit2(&_gzipStream, 16 + MAX_WBITS) != Z_OK) {
         [self.client URLProtocol:self didFailWithError:[[NSError alloc] initWithDomain:@"gzip initialize fail" code:-1 userInfo:nil]];
       }
     }
     return self;
   }
   
   /**
    *  Specifies whether to intercept and process the specified request.
    *
    *  @param request The specified request.
    *  @return Returns YES to intercept and process the request, or NO to not intercept the request.
    */
   + (BOOL)canInitWithRequest:(NSURLRequest *)request {
     if([[request.URL absoluteString] isEqual:@"about:blank"]) {
       return NO;
     }
   
     // Prevents infinite loops. A request may be re-initiated during interception. If this is not handled, an infinite loop occurs.
     if ([NSURLProtocol propertyForKey:hasBeenInterceptedCustomLabelKey inRequest:request]) {
       return NO;
     }
   
     NSString * url = request.URL.absoluteString;
     NSString * domain = request.URL.host;
   
     // Intercept only HTTPS requests.
     if (![url hasPrefix:@"https"]) {
       return NO;
     }
   
     // You can add more conditions as needed, such as configuring a host array to intercept only the hosts in the array.
   
     // Intercept only requests whose hosts are replaced with IP addresses.
     if (![self isPlainIpAddress:domain]) {
       return NO;
     }
     return YES;
   }
   
   + (BOOL)isPlainIpAddress:(NSString *)hostStr {
     if (!hostStr) {
       return NO;
     }
   
     // Checks whether the address is an IPv4 address.
     const char *utf8 = [hostStr UTF8String];
     int success = 0;
     struct in_addr dst;
     success = inet_pton(AF_INET, utf8, &dst);
     if (success == 1) {
       return YES;
     }
   
     // Checks whether the address is an IPv6 address.
     struct in6_addr dst6;
     success = inet_pton(AF_INET6, utf8, &dst6);
     if (success == 1) {
       return YES;
     }
   
     return NO;
   }
   
   // To redirect the request or add headers, perform the operations in this method.
   + (NSURLRequest *)canonicalRequestForRequest:(NSURLRequest *)request {
     return request;
   }
   
   // Starts to load the request.
   - (void)startLoading {
     NSMutableURLRequest *request = [self.request mutableCopy];
     // Indicates that the request has been processed. This prevents infinite loops.
     [NSURLProtocol setProperty:@(YES) forKey:hasBeenInterceptedCustomLabelKey inRequest:request];
     self.curRequest = [self createNewRequest:request];
     [self startRequest];
   }
   
   - (NSString *)cookieForURL:(NSURL *)URL {
     NSHTTPCookieStorage *cookieStorage = [NSHTTPCookieStorage sharedHTTPCookieStorage];
     NSMutableArray *cookieList = [NSMutableArray array];
     for (NSHTTPCookie *cookie in [cookieStorage cookies]) {
       if (![self p_checkCookie:cookie URL:URL]) {
         continue;
       }
       [cookieList addObject:cookie];
     }
   
     if (cookieList.count > 0) {
       NSDictionary *cookieDic = [NSHTTPCookie requestHeaderFieldsWithCookies:cookieList];
       if ([cookieDic objectForKey:@"Cookie"]) {
         return cookieDic[@"Cookie"];
       }
     }
     return nil;
   }
   
   
   - (BOOL)p_checkCookie:(NSHTTPCookie *)cookie URL:(NSURL *)URL {
     if (cookie.domain.length <= 0 || URL.host.length <= 0) {
       return NO;
     }
     if ([URL.host containsString:cookie.domain]) {
       return YES;
     }
     return NO;
   }
   
   - (NSMutableURLRequest *)createNewRequest:(NSURLRequest*)request {
     NSURL* originUrl = request.URL;
     NSString *cookie = [self cookieForURL:originUrl];
   
     NSMutableURLRequest* mutableRequest = [request copy];
     [mutableRequest setValue:cookie forHTTPHeaderField:@"Cookie"];
   
     return [mutableRequest copy];
   }
   
   /**
    * Cancels the request.
    */
   - (void)stopLoading {
     if (_inputStream.streamStatus == NSStreamStatusOpen) {
       [self closeStream:_inputStream];
     }
     [self.client URLProtocol:self didFailWithError:[[NSError alloc] initWithDomain:@"stop loading" code:-1 userInfo:nil]];
   }
   
   /**
    * Forwards the request using CFHTTPMessage.
    */
   - (void)startRequest {
     // The header information of the original request.
     NSDictionary *headFields = _curRequest.allHTTPHeaderFields;
     CFStringRef url = (__bridge CFStringRef) [_curRequest.URL absoluteString];
     CFURLRef requestURL = CFURLCreateWithString(kCFAllocatorDefault, url, NULL);
   
     // The method of the original request, such as GET or POST.
     CFStringRef requestMethod = (__bridge_retained CFStringRef) _curRequest.HTTPMethod;
   
     // Creates a CFHTTPMessageRef object based on the URL, method, and version of the request.
     CFHTTPMessageRef cfrequest = CFHTTPMessageCreateRequest(kCFAllocatorDefault, requestMethod, requestURL, kCFHTTPVersion1_1);
   
     // Adds the data attached to the HTTP POST request.
     CFStringRef requestBody = CFSTR("");
     CFDataRef bodyData = CFStringCreateExternalRepresentation(kCFAllocatorDefault, requestBody, kCFStringEncodingUTF8, 0);
   
     if (_curRequest.HTTPBody) {
       bodyData = (__bridge_retained CFDataRef) _curRequest.HTTPBody;
     }  else if (_curRequest.HTTPBodyStream) {
       NSData *data = [self dataWithInputStream:_curRequest.HTTPBodyStream];
       NSString *strBody = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
       NSLog(@"originStrBody: %@", strBody);
   
       CFDataRef body = (__bridge_retained CFDataRef) data;
       CFHTTPMessageSetBody(cfrequest, body);
       CFRelease(body);
     } else {
       CFHTTPMessageSetBody(cfrequest, bodyData);
     }
   
     // Copies the header information of the original request.
     for (NSString* header in headFields) {
       CFStringRef requestHeader = (__bridge CFStringRef) header;
       CFStringRef requestHeaderValue = (__bridge CFStringRef) [headFields valueForKey:header];
       CFHTTPMessageSetHeaderFieldValue(cfrequest, requestHeader, requestHeaderValue);
     }
   
     // Creates an input stream for the CFHTTPMessage object.
     #pragma clang diagnostic push
     #pragma clang diagnostic ignored "-Wdeprecated-declarations"
     CFReadStreamRef readStream = CFReadStreamCreateForHTTPRequest(kCFAllocatorDefault, cfrequest);
     #pragma clang diagnostic pop
     self.inputStream = (__bridge_transfer NSInputStream *) readStream;
   
     // Sets the Server Name Indication (SNI) host information. This is a key step.
     NSString *host = [_curRequest.allHTTPHeaderFields objectForKey:@"host"];
     if (!host) {
       host = _curRequest.URL.host;
     }
   
     [_inputStream setProperty:NSStreamSocketSecurityLevelNegotiatedSSL forKey:NSStreamSocketSecurityLevelKey];
     NSDictionary *sslProperties = [[NSDictionary alloc] initWithObjectsAndKeys: host, (__bridge id) kCFStreamSSLPeerName, nil];
     [_inputStream setProperty:sslProperties forKey:(__bridge_transfer NSString *) kCFStreamPropertySSLSettings];
     [_inputStream setDelegate:self];
   
     if (!_curRunLoop) {
       // Saves the runloop of the current thread. This is critical for redirected requests.
       self.curRunLoop = [NSRunLoop currentRunLoop];
     }
     // Adds the request to the event queue of the current runloop.
     [_inputStream scheduleInRunLoop:_curRunLoop forMode:NSRunLoopCommonModes];
     [_inputStream open];
   
     CFRelease(cfrequest);
     CFRelease(requestURL);
     cfrequest = NULL;
     CFRelease(bodyData);
     CFRelease(requestBody);
     CFRelease(requestMethod);
   }
   
   - (NSData*)dataWithInputStream:(NSInputStream*)stream {
     NSMutableData *data = [NSMutableData data];
     [stream open];
     NSInteger result;
     uint8_t buffer[1024];
   
     while ((result = [stream read:buffer maxLength:1024]) != 0) {
       if (result > 0) {
         // buffer contains result bytes of data to be handled
         [data appendBytes:buffer length:result];
       } else if (result < 0) {
         // The stream had an error. You can get an NSError object using [iStream streamError]
         data = nil;
         break;
       }
     }
     [stream close];
     return data;
   }
   
   #pragma mark - NSStreamDelegate
   /**
    * The callback function after the input stream receives the complete header.
    */
   - (void)stream:(NSStream *)aStream handleEvent:(NSStreamEvent)eventCode {
     if (eventCode == NSStreamEventHasBytesAvailable) {
       CFReadStreamRef readStream = (__bridge_retained CFReadStreamRef) aStream;
       #pragma clang diagnostic push
       #pragma clang diagnostic ignored "-Wdeprecated-declarations"
       CFHTTPMessageRef message = (CFHTTPMessageRef) CFReadStreamCopyProperty(readStream, kCFStreamPropertyHTTPResponseHeader);
       #pragma clang diagnostic pop
       if (CFHTTPMessageIsHeaderComplete(message)) {
         NSInputStream *inputstream = (NSInputStream *) aStream;
         NSNumber *alreadyAdded = objc_getAssociatedObject(aStream, (__bridge const void *)(kAnchorAlreadyAdded));
         NSDictionary *headDict = (__bridge NSDictionary *) (CFHTTPMessageCopyAllHeaderFields(message));
   
         if (!alreadyAdded || ![alreadyAdded boolValue]) {
           objc_setAssociatedObject(aStream, (__bridge const void *)(kAnchorAlreadyAdded), [NSNumber numberWithBool:YES], OBJC_ASSOCIATION_COPY);
           // Notifies the client that the response is received. This notification is sent only once.
   
           CFStringRef httpVersion = CFHTTPMessageCopyVersion(message);
           // Obtains the status code from the response header.
           CFIndex statusCode = CFHTTPMessageGetResponseStatusCode(message);
   
           if (!self.responseIsHandle) {
             NSHTTPURLResponse *response = [[NSHTTPURLResponse alloc] initWithURL:_curRequest.URL statusCode:statusCode
                                                      HTTPVersion:(__bridge NSString *) httpVersion headerFields:headDict];
             [self.client URLProtocol:self didReceiveResponse:response cacheStoragePolicy:NSURLCacheStorageNotAllowed];
             self.responseIsHandle = YES;
           }
   
           // Verifies the certificate.
           SecTrustRef trust = (__bridge SecTrustRef) [aStream propertyForKey:(__bridge NSString *) kCFStreamPropertySSLPeerTrust];
           SecTrustResultType res = kSecTrustResultInvalid;
           NSMutableArray *policies = [NSMutableArray array];
           NSString *domain = [[_curRequest allHTTPHeaderFields] valueForKey:@"host"];
           if (domain) {
             [policies addObject:(__bridge_transfer id) SecPolicyCreateSSL(true, (__bridge CFStringRef) domain)];
           } else {
             [policies addObject:(__bridge_transfer id) SecPolicyCreateBasicX509()];
           }
   
           // Binds the verification policy to the server certificate.
           SecTrustSetPolicies(trust, (__bridge CFArrayRef) policies);
           if (SecTrustEvaluate(trust, &res) != errSecSuccess) {
             [self closeStream:aStream];
             [self.client URLProtocol:self didFailWithError:[[NSError alloc] initWithDomain:@"can not evaluate the server trust" code:-1 userInfo:nil]];
             return;
           }
           if (res != kSecTrustResultProceed && res != kSecTrustResultUnspecified) {
             // If the certificate fails to be verified, close the input stream.
             [self closeStream:aStream];
             [self.client URLProtocol:self didFailWithError:[[NSError alloc] initWithDomain:@"fail to evaluate the server trust" code:-1 userInfo:nil]];
           } else {
             // The certificate is verified.
             if (statusCode >= 300 && statusCode < 400) {
               // Handles the redirection error code.
               [self closeStream:aStream];
               [self handleRedirect:message];
             } else {
               NSError *error = nil;
               NSData *data = [self readDataFromInputStream:inputstream headerDict:headDict stream:aStream error:&error];
               if (error) {
                 [self.client URLProtocol:self didFailWithError:error];
               } else {
                 [self.client URLProtocol:self didLoadData:data];
               }
             }
           }
         } else {
           NSError *error = nil;
           NSData *data = [self readDataFromInputStream:inputstream headerDict:headDict stream:aStream error:&error];
           if (error) {
             [self.client URLProtocol:self didFailWithError:error];
           } else {
             [self.client URLProtocol:self didLoadData:data];
           }
         }
         CFRelease((CFReadStreamRef)inputstream);
         CFRelease(message);
       }
     } else if (eventCode == NSStreamEventErrorOccurred) {
       [self closeStream:aStream];
       inflateEnd(&_gzipStream);
       // Notifies the client that an error occurred.
       [self.client URLProtocol:self didFailWithError:
            [[NSError alloc] initWithDomain:@"NSStreamEventErrorOccurred" code:-1 userInfo:nil]];
     } else if (eventCode == NSStreamEventEndEncountered) {
       CFReadStreamRef readStream = (__bridge_retained CFReadStreamRef) aStream;
       #pragma clang diagnostic push
       #pragma clang diagnostic ignored "-Wdeprecated-declarations"
       CFHTTPMessageRef message = (CFHTTPMessageRef) CFReadStreamCopyProperty(readStream, kCFStreamPropertyHTTPResponseHeader);
       #pragma clang diagnostic pop
       if (CFHTTPMessageIsHeaderComplete(message)) {
         NSNumber *alreadyAdded = objc_getAssociatedObject(aStream, (__bridge const void *)(kAnchorAlreadyAdded));
         NSDictionary *headDict = (__bridge NSDictionary *) (CFHTTPMessageCopyAllHeaderFields(message));
   
         if (!alreadyAdded || ![alreadyAdded boolValue]) {
           objc_setAssociatedObject(aStream, (__bridge const void *)(kAnchorAlreadyAdded), [NSNumber numberWithBool:YES], OBJC_ASSOCIATION_COPY);
           // Notifies the client that the response is received. This notification is sent only once.
   
           if (!self.responseIsHandle) {
             CFStringRef httpVersion = CFHTTPMessageCopyVersion(message);
             // Obtains the status code from the response header.
             CFIndex statusCode = CFHTTPMessageGetResponseStatusCode(message);
             NSHTTPURLResponse *response = [[NSHTTPURLResponse alloc] initWithURL:_curRequest.URL statusCode:statusCode
                                                      HTTPVersion:(__bridge NSString *) httpVersion headerFields:headDict];
             [self.client URLProtocol:self didReceiveResponse:response cacheStoragePolicy:NSURLCacheStorageNotAllowed];
             self.responseIsHandle = YES;
           }
         }
       }
   
       [self closeStream:_inputStream];
       inflateEnd(&_gzipStream);
       [self.client URLProtocolDidFinishLoading:self];
     }
   }
   
   - (NSData *)readDataFromInputStream:(NSInputStream *)inputStream headerDict:(NSDictionary *)headDict stream:(NSStream *)aStream error:(NSError **)error {
     // In case the response header is incomplete.
     UInt8 buffer[16 * 1024];
   
     NSInteger length = [inputStream read:buffer maxLength:sizeof(buffer)];
     if (length < 0) {
       *error = [[NSError alloc] initWithDomain:@"inputstream length is invalid"
                     code:-2
                     userInfo:nil];
       [aStream removeFromRunLoop:_curRunLoop forMode:NSRunLoopCommonModes];
       [aStream setDelegate:nil];
       [aStream close];
       return nil;
     }
   
     NSData *data = [[NSData alloc] initWithBytes:buffer length:length];
     if (headDict[@"Content-Encoding"] && [headDict[@"Content-Encoding"] containsString:@"gzip"]) {
       data = [self gzipUncompress:data];
       if (!data) {
         *error = [[NSError alloc] initWithDomain:@"can't read any data"
                         code:-3
                         userInfo:nil];
         return nil;
       }
     }
   
     return data;
   }
   
   - (void)closeStream:(NSStream*)stream {
     [stream removeFromRunLoop:_curRunLoop forMode:NSRunLoopCommonModes];
     [stream setDelegate:nil];
     [stream close];
   }
   
   - (void)handleRedirect:(CFHTTPMessageRef)messageRef {
     // Response header.
     CFDictionaryRef headerFieldsRef = CFHTTPMessageCopyAllHeaderFields(messageRef);
     NSDictionary *headDict = (__bridge_transfer NSDictionary *)headerFieldsRef;
     [self redirect:headDict];
   }
   
   - (void)redirect:(NSDictionary *)headDict {
     // If cookies are required for redirection, handle them.
     NSString *location = headDict[@"Location"];
     if (!location)
       location = headDict[@"location"];
     NSURL *url = [[NSURL alloc] initWithString:location];
     _curRequest.URL = url;
     if ([[_curRequest.HTTPMethod lowercaseString] isEqualToString:@"post"]) {
       // According to the RFC documentation, when a POST request is redirected, it must be converted to a GET request.
       _curRequest.HTTPMethod = @"GET";
       _curRequest.HTTPBody = nil;
     }
     [self startRequest];
   }
   
   - (NSData *)gzipUncompress:(NSData *)gzippedData {
     if ([gzippedData length] == 0) {
       return gzippedData;
     }
   
     unsigned full_length = (unsigned) [gzippedData length];
     unsigned half_length = (unsigned) [gzippedData length] / 2;
   
     NSMutableData *decompressed = [NSMutableData dataWithLength:full_length + half_length];
     BOOL done = NO;
     int status;
     _gzipStream.next_in = (Bytef *)[gzippedData bytes];
     _gzipStream.avail_in = (uInt)[gzippedData length];
     _gzipStream.total_out = 0;
   
     while (_gzipStream.avail_in != 0 && !done) {
       if (_gzipStream.total_out >= [decompressed length]) {
         [decompressed increaseLengthBy:half_length];
       }
   
       _gzipStream.next_out = (Bytef *)[decompressed mutableBytes] + _gzipStream.total_out;
       _gzipStream.avail_out = (uInt)([decompressed length] - _gzipStream.total_out);
   
       status = inflate(&_gzipStream, Z_SYNC_FLUSH);
   
       if (status == Z_STREAM_END) {
         done = YES;
       } else if (status == Z_BUF_ERROR) {
         // If Z_BUF_ERROR is caused by an insufficient output buffer, the input buffer is not fully processed and the output buffer is full. In this case, the loop must continue to expand the buffer.
         // The opposite condition indicates that the error is not caused by an insufficient output buffer. In this case, the loop must be terminated, which indicates an error.
         if (_gzipStream.avail_in == 0 || _gzipStream.avail_out != 0) {
           return nil;
         }
       } else if (status != Z_OK) {
               return nil;
           }
       }
   
       [decompressed setLength:_gzipStream.total_out];
       return [NSData dataWithData:decompressed];
   }
   
   @end
   

2. Implement a custom BeforeSend.

   - (void)setupHttpDNS:(NSString *)accountId {
     // Configures HTTPDNS.
     HttpDnsService *httpdns = [[HttpDnsService alloc] initWithAccountID:accountId];
     [httpdns setHTTPSRequestEnabled:YES];
     [httpdns setPersistentCacheIPEnabled:YES];
     [httpdns setReuseExpiredIPEnabled:YES];
     [httpdns setIPv6Enabled:YES];
   
     NSURLSessionConfiguration *configuration = [NSURLSessionConfiguration defaultSessionConfiguration];
   
     NSMutableArray *protocolsArray = [NSMutableArray arrayWithArray:configuration.protocolClasses];
     // Sets the custom NSURLProtocol defined above.
     [protocolsArray insertObject:[HttpDnsNSURLProtocolImpl class] atIndex:0];
     [configuration setProtocolClasses:protocolsArray];
     NSURLSession *session = [NSURLSession sessionWithConfiguration:configuration delegate:nil delegateQueue:nil];
   
     [SLSURLSession setURLSession:session];
     [SLSURLSession setBeforeSend:^NSMutableURLRequest * _Nonnull(NSMutableURLRequest * _Nonnull request) {
       NSURL *url = request.URL;
       // You can add a condition here to apply this only to required URLs.
       
       HttpdnsResult *result = [httpdns resolveHostSync:url.host byIpType:HttpdnsQueryIPTypeAuto];
       if (!result) {
         return request;
       }
   
       NSString *ipAddress = nil;
       if (result.hasIpv4Address) {
         ipAddress = result.firstIpv4Address;
       } else if(result.hasIpv6Address) {
         ipAddress = result.firstIpv6Address;
       } else {
         return request;
       }
   
       NSString *requestUrl = url.absoluteString;
       requestUrl = [requestUrl stringByReplacingOccurrencesOfString: url.host withString:ipAddress];
   
       [request setURL:[NSURL URLWithString:requestUrl]];
       [request setValue:url.host forHTTPHeaderField:@"host"];
   
       return request;
     }];
   }

3. Complete the SLS SDK initialization.

   @implementation AliyunSLS
   
   - (void)initSLS {
     // Sets custom HTTPDNS for the SLS SDK.
     // !!!Note!!!
     // This setting takes effect for all SLS SDK instances.
     [self setupHttpDNS:accountId];
     [self initProducer];
   }
   
   - (void)initProducer {
       // Initialize LogProducerConfig and LogProducerClient as you normally would.
       // ...
   }
   
   @end