class Trace
{
    public static function getServerIp() {
        if (isset($_SERVER)) {
            if(isset($_SERVER['SERVER_ADDR'])) {
                $server_ip = $_SERVER['SERVER_ADDR'];
            } else {
                if(isset($_SERVER['LOCAL_ADDR']))
                    $server_ip = $_SERVER['LOCAL_ADDR'];
            }
        } else {
            $server_ip = getenv('SERVER_ADDR');
        }
        if(!isset($server_ip) || $server_ip == "127.0.0.1" || $server_ip == 0){
            $sock = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);
            socket_connect($sock, "8.8.8.8", 53);
            socket_getsockname($sock, $server_ip);
            $_SERVER['SERVER_ADDR'] = $server_ip;
        }
        return isset($server_ip) ? $server_ip : 0;
    }
 
    public static function generateTraceId($appId)
    {
        $ip = self::getServerIp();
        if ($ip == 0) {
            $cmd = "ifconfig | grep -A1 'eth0' | grep 'inet addr:' | awk '{print $2}' | awk -F ':' '{print $2}'";
            $ip = shell_exec($cmd);
            if(empty($ip)){
                $ip = "127.0.0.1";
            }
        }
        $timestamp = time();
        $timeNano = sprintf("%d", microtime(true) * 1e9);
        $ip = explode('.', $ip);
        $pid = getmypid();
        $str = '';
        foreach ($ip as $num) {
            $str .= sprintf("%02x", $num);
        }
        $str .= sprintf("%x", $timestamp & 0xffffffff);
        $str .= sprintf("%04x", $timeNano & 0xffff);
        $str .= sprintf("%04x", $pid & 0xffff);
        $str .= sprintf("%06x", rand(0,(1<<24)-1));
        $str .= sprintf("%02x", $appId % 1000 + 32);
 
        return $str;
    }
}
 
echo Trace::generateTraceId(1002);

                            

package main
 
 
import (
    "bytes"
    "encoding/hex"
    "fmt"
    "math/rand"
    "net"
    "os"
    "time"
)
 
var (
    ip string
)
 
//GenTraceId
func GenTraceId(appId int) string {
    if ip == "" {
        ip = getLocalIP()
    }
    now := time.Now()
    timestamp := uint32(now.Unix())
    timeNano := now.UnixNano()
    pid := os.Getpid()
    b := bytes.Buffer{}
 
    b.WriteString(hex.EncodeToString(net.ParseIP(ip).To4()))
    b.WriteString(fmt.Sprintf("%x", timestamp&0xffffffff))
    b.WriteString(fmt.Sprintf("%04x", timeNano&0xffff))
    b.WriteString(fmt.Sprintf("%04x", pid&0xffff))
    b.WriteString(fmt.Sprintf("%06x", rand.Int31n(1<<24)))
    b.WriteString(fmt.Sprintf("%02x", appId % 1000 + 32))
 
    return b.String()
}
 
func getLocalIP() string {
    ip := "127.0.0.1"
    addrs, err := net.InterfaceAddrs()
    if err != nil {
        return ip
    }
    for _, a := range addrs {
        if ipnet, ok := a.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
            if ipnet.IP.To4() != nil {
                ip = ipnet.IP.String()
                break
            }
        }
    }
 
    return ip
}
 
func main() {
    print(GenTraceId(1002))
}
                        

import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;
 
 
public class TraceId {
 
    public static void main(String[] args) {
        // app_id
        System.out.print(getTraceId(1002));
    }
 
    private static final long ipFactor = getIpFactor();
    private static AtomicLong counter = new AtomicLong();
 
    static {
        counter.set(0);
    }
 
    private static long ip2long(String ip) {
        int ret = 0;
        String ipGroups[] = ip.split("\\.");
        Integer[] ipInt = new Integer[4];
        for (int i = 0; i < ipGroups.length; i++) {
            ipInt[i] = Integer.valueOf(ipGroups[i]);
        }
        ret = ipInt[0] << 24 | ipInt[1] << 16 | ipInt[2] << 8 | ipInt[3];
        return ret;
    }
 
    private static long timeFactor() {
        Date data = new Date();
        long msec = data.getTime();
        return msec;
    }
 
    private static long timeFactorInSecond() {
        return timeFactor() / 1000;
    }
 
    private static long randFactor() {
        long ret = (long) (Math.random() * Math.pow(2, 32));
        return ret;
    }
 
    private static List getLocalIpList() {
        List ipList = new ArrayList();
        try {
            Enumeration networkInterfaces = NetworkInterface.getNetworkInterfaces();
            NetworkInterface networkInterface;
            Enumeration inetAddresses;
            InetAddress inetAddress;
            String ip;
            while (networkInterfaces.hasMoreElements()) {
                networkInterface = networkInterfaces.nextElement();
                inetAddresses = networkInterface.getInetAddresses();
                while (inetAddresses.hasMoreElements()) {
                    inetAddress = inetAddresses.nextElement();
                    if (inetAddress != null && inetAddress instanceof Inet4Address) { // IPV4
                        ip = inetAddress.getHostAddress();
                        ipList.add(ip);
                    }
                }
            }
        } catch (SocketException e) {
        }
        return ipList;
    }
 
    private static long getIpFactor() {
        List ips = getLocalIpList();
        String ipAddr = "127.0.0.1";
        if (ips == null || ips.size() == 0) {
            return ip2long(ipAddr);
        }
        for (String iptmp : ips) {
            if (iptmp.equals("127.0.0.1")) {
                continue;
            } else {
                ipAddr = iptmp;
                break;
            }
        }
        return ip2long(ipAddr);
    }
 
    public static String getTraceId(int appId) {
        appId = appId % 1000 + 32;
        long timeFactor = timeFactorInSecond();
        long randFactor1 = randFactor();
        long randFactor2 = counter.incrementAndGet();
        long traceIdpart1 = ipFactor << 32 | (timeFactor & 0xffffffff);
        long traceIdpart2 = randFactor1 << 32 | (randFactor2 & 0xffffff) << 8 | appId;
        return handleFormat(Long.toHexString(traceIdpart1), 16) + handleFormat(Long.toHexString(traceIdpart2), 16);
    }
 
    private static String handleFormat(String value, int digit) {
        if (value == null) {
            return "00000000";
        }
        while (value.length() < digit) {
            value = "0" + value;
        }
        return value;
    }
}