Proxy support about datadog-api-client-typescript HOT 5 CLOSED

import { v1 } from "@datadog/datadog-api-client";                                                                                                    
import pako from "pako";                                                                                                                             
import bufferFrom from "buffer-from";                                                                                                                
import fetch from "node-fetch";                                                                                                                      
import { HttpsProxyAgent } from "https-proxy-agent";                                                                                                 
                                                                                                                                                     
const proxyAgent = new HttpsProxyAgent('http://proxy:port');                                                                                         
                                                                                                                                                     
class HttpLibraryWithProxy implements v1.HttpLibrary {                                                                                               
  public debug = false;                                                                                                                              
                                                                                                                                                     
  public send(request: v1.RequestContext): Promise<v1.ResponseContext> {                                                                             
    const method = request.getHttpMethod().toString();                                                                                               
    let body = request.getBody();                                                                                                                    
                                                                                                                                                     
    let compress = request.getHttpConfig().compress;                                                                                                 
    if (compress === undefined) {                                                                                                                    
      compress = true;                                                                                                                               
    }                                                                                                                                                
                                                                                                                                                     
    const headers = request.getHeaders();                                                                                                            
    if (typeof body === "string") {                                                                                                                  
      if (headers["Content-Encoding"] == "gzip") {                                                                                                   
        body = bufferFrom(pako.gzip(body).buffer);                                                                                                   
      } else if (headers["Content-Encoding"] == "deflate") {                                                                                         
        body = bufferFrom(pako.deflate(body).buffer);                                                                                                
      }                                                                                                                                              
    }                                                                                                                                                
                                                                                                                                                     
    const resultPromise = fetch(request.getUrl(), {                                                                                                  
      method: method,                                                                                                                                
      body: body as any,                                                                                                                             
      headers: headers,                                                                                                                              
      signal: request.getHttpConfig().signal,                                                                                                        
      compress: compress,                                                                                                                            
      agent: proxyAgent,                                                                                                                             
    }).then((resp: any) => {                                                                                                                         
      const headers: { [name: string]: string } = {};                                                                                                
      resp.headers.forEach((value: string, name: string) => {                                                                                        
        headers[name] = value;                                                                                                                       
      });                                                                                                                                            
                                                                                                                                                     
      const body = {                                                                                                                                 
        text: () => resp.text(),                                                                                                                     
        binary: () => resp.buffer(),                                                                                                                 
      };                                                                                                                                             
      const response = new v1.ResponseContext(resp.status, headers, body);                                                                           
      return response;                                                                                                                               
    });                                                                                                                                              
                                                                                                                                                     
    return resultPromise;                                                                                                                            
  }                                                                                                                                                  
}                                                                                                                                                    
                                                                                                                                                     
const configuration = v1.createConfiguration({httpApi: new HttpLibraryWithProxy()});                                                                 
const apiInstance = new v1.MonitorsApi(configuration);                                                                                               
                                                                                                                                                     
apiInstance                                                                                                                                          
  .listMonitors()                                                                                                                                    
  .then((data: v1.Monitor[]) => {                                                                                                                    
    console.log(                                                                                                                                     
      "API called successfully. Returned data: " + JSON.stringify(data)                                                                              
    );                                                                                                                                               
  })                                                                                                                                                 
  .catch((error: any) => console.error(error));