RunnerLee

今晚80后脱口秀

Mon, 20 Jul 2020 00:00:00 +0000

11 年刚来广州读书那会知道了今晚80后脱口秀，刚开始每期都追，那时候优酷这些还没有这节目，只能上央视影音上看。

每天食堂打了饭跑回宿舍开电脑，开头啥的都忘了，就只记得刚开始是红酒冠名，然后趣多多，然后红牛。

每期都会给 DJ 挺多特写，节目的开头都是王自健那个死胖子冲出来。

请过很多那时候压根不知道的明星，Jason Mraz 上节目唱了 “I’m Yours”，黄龄也上了挺多期，还有就是王自健那句贼啰嗦的口头禅 “我的好朋友赖宝建国蛋蛋”。

后来看得少了，慢慢地王自健这句口头禅里没了赖宝只剩下建国蛋蛋，直到完全没看了，再后来节目也停播了。

今天微博看到赖宝去世，唉。

今夜有你们真好, 希望你们今夜过得开心

单元测试的对象mocking

Mon, 04 May 2020 00:00:00 +0000

通过 laravel 的 testing 了解到 mockery/mockery 这个包。这个包主要有两个功能：Method Stubs 和 Test Spies.

使用比较好上手，看下 laravel facade 中的集成 mockery 的使用和实现

# https://laravel.com/docs/7.x/mocking#mocking-facades

use SomeServiceFacade;    // facade
use Tests\TestCase;

class SomeTest extend TestCase
{
    public function testSomething()
    {
        SomeServiceFacade::shouldReceive('foo')
            ->once()
            ->with('bar')
            ->andReturn('val');

        // do some testing
    }
}

在这段测试中，SomeServiceFacade 是一个 facade，如果没有调用到 SomeServiceFacade::foo() 或是调用次数大于一次就会抛异常，调用到时会返回 val.

并且当测试步骤中，通过 SomeServiceFacade::getFacadeRoot() 获取到的 facade 的 root object 实际上是 Mockery\Mock 实例。

namespace Illuminate\Support\Facades;

abstract class Facade
{
    public static function shouldReceive()
    {
        $name = static::getFacadeAccessor();

        $mock = static::isMock()
                    ? static::$resolvedInstance[$name]
                    : static::createFreshMockInstance();

        return $mock->shouldReceive(...func_get_args());
    }

    protected static function createFreshMockInstance()
    {
        return tap(static::createMock(), function ($mock) {
            static::swap($mock);

            $mock->shouldAllowMockingProtectedMethods();
        });
    }
}

这个功能我一般来用测试调用了子系统或外部系统的地方。例如某个功能需要调用子系统获取数据并加工后返回给客户端，在编写测试时，

php 的 es query builder

Sun, 22 Mar 2020 00:00:00 +0000

先直接贴 GitHub repo: RunnerLee/esq-builder

自己在实际项目里面比较少用到 es，没什么深度使用的场景。根据几个遇到的基础使用场景总结，想要解决几个问题：

简化查询条件拼接
不过度隐藏 dsl 细节
满足简单的查询和统计要求

在此之前，想要做一个简单的列表搜索，例如 “商品末级分类+商品名称前缀+创建者/维护者”，在 php 中需要拼装这样非常不直观的数组：

$query = [
    'bool' => [
        'must' => [
            [
                'term' => [
                    'category_id' => 1,
                ],
            ],
            [
                'prefix' => [
                    'goods_name' => 'abc',
                ],
            ],
            [
                'bool' => [
                    'should' => [
                        [
                            'term' => [
                                'create_uid' => 'runnerlee',
                            ],
                        ],
                        [
                            'term' => [
                                'update_uid' => 'runnerlee',
                            ],
                        ]
                    ],
                ],
            ]
        ],
    ],
];

在 GitHub 搜轮子搜到这个：https://github.com/ongr-io/ElasticsearchDSL

他的用法是这样的：

$matchAll = new ONGR\ElasticsearchDSL\Query\MatchAllQuery();
$search = new ONGR\ElasticsearchDSL\Search();
$search->addQuery($matchAll);
$params = [
    'index' => 'your_index',
    'body' => $search->toArray(),
];

$results = $client->search($params);

结合平常用的 laravel 的 eloquent，我想要能否这样去拼装我的查询:

$query = new QueryBuilder();
$query
    ->term('demo_field', 'demo_value')
    ->prefix('demo_field_2', 'demo_value_2');


// 一开始想过用这种形势
// $query->where('term', 'demo_field', 'demo_value');
// 或者是这种
// $query->whereTerm('demo_field', 'demo_value');
// 但觉得这样在阅读代码理解查询逻辑时不太友善

借用 ongr/elasticsearch-dsl 套一层封装，现在对最上面的例子可以这么处理了：

use Runner\EsqBuilder\QueryBuilder;
use Runner\EsqBuilder\SearchBuilder;

$builder = new SearchBuilder();

$builder->query()
    ->term('category_id', 1)
    ->prefix('goods_name', 'abc')
    ->bool(function (QueryBuilder $query) {
        $query->shouldTerm('create_uid', 'runnerlee')
            ->shouldTerm('update_uid', 'runnerlee');
    });

感觉还是清爽的。在 QueryBuilder 中，把 query 当作是一个大的 bool, 你可以直接调用支持的 clause 来往 bool 里加查询条件，默认的类型为 must.

你也可以用 <boolType><clause> 来指定 clause 的类型。例如 $query->shouldTerm() 或是 $query->mustNotTerm().

嵌套 bool 的使用就跟 eloquent 的 Model::query() 方法类似了。

整个 SearchBuilder 由四个 components 组成：

QueryBuilder
AggregationBuilder
SortBuilder
HighlightBuilder

给上面的例子加上排序和分页：

$page = min(100, max(1, $_GET['page'] ?? 1));
$perPage = 20;
$builder->setFrom(($page - 1) * $perPage);
$builder->setSize($perPage);
$builder->sort()->fieldSort('id', 'desc');

$response = $builder
    ->setClient(ClientBuilder::create()->build())
    ->serach('your_index');

参考

才想起来我的博客

Fri, 13 Mar 2020 00:00:00 +0000

这段时间过得其实并不愉快，工作生活发生了很多不愉快的事。但好在还是挺过来了，还是要接着加油呀。

接下来尽量多记录一些好玩的事，多学点东西。

以梦为马，不负韶华。

symfony workflow 使用

Wed, 28 Aug 2019 00:00:00 +0000

看到部门其他组的项目用到了 symfony/workflow 这个包, 看了一下文档, 用在状态机场景时相比之前自己写的状态机有几个比较好的特性:

更加丰富全面的触发事件
灵活 marking store 可以用来处理多种形态的 subject
metadata 绑定
基于配置文件配置及关联 subject

摘抄一些概念

symfony/workflow 是一个 Petri 网的实现, 而状态机 (state machine) 是它的一个子集. 更多的概念就不深入 (想深入也深入不了呀…), 摘抄一下其中几个重要的名词和概念:

一个 Petri 网模型包含这些元素:

place 库所
transition 变迁
Arc 有向弧
Token 令牌

一个工作流的 definition 包括 places 和actions, 以从一个位置来到另一个位置. actions 被称为 transistions. 工作流也需要知道每个对象在工作流中的位置. 那个 marking store 写入了对象的一个属性来记住当前位置.

动手实操

假设有订单表, 订单有已下单 / 已支付 / 已完成 / 已退款四个状态, 他的状态机定义是这样的

使用 symfony/workflow 来定义这个状态机:

$config = [
    'order' => [
        'type' => 'state_machine',
        'single_status' => true,
        'marking_property' => 'status',
        'support' => Order::class,
        'places' => [
            'created',
            'paid',
            'completed',
            'refunded',
        ],
        'transitions' => [
            'to_pay' => [
                'from' => 'created',
                'to' => 'paid',
            ],
            'to_complete' => [
                'from' => 'paid',
                'to' => 'completed',
            ],
            'to_refund' => [
                'from' => 'paid',
                'to' => 'refund',
            ],
        ],
    ],
];

定义 Order

class Order
{
    protected $status;

    public function setStatus($status)
    {
        $this->status = $status;
    }

    public function getStatus()
    {
        return $this->status;
    }
}

创建 workflow:

use Symfony\Component\Workflow\Registry;
use Symfony\Component\Workflow\Transition;
use Symfony\Component\Workflow\StateMachine;
use Symfony\Component\Workflow\DefinitionBuilder;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\Workflow\SupportStrategy\InstanceOfSupportStrategy;

$builder = new DefinitionBuilder();

$builder->addPlaces($config['order']['places']);

foreach ($config['order']['transitions'] as $name => $transition) {
    $builder->addTransition(new Transition($name, $transition['from'], $transition['to']));
}

$dispatcher = new EventDispatcher();

$workflow = new StateMachine(
    $builder->build(),
    new MethodMarkingStore($config['order']['single_status'], $config['order']['marking_property']),
    $dispatcher,
    'order'
);

$registry = new Registry();

$registry->addWorkflow($workflow, new InstanceOfSupportStrategy($config['order']['support']));

接下来就是使用啦:

$order = new Order();

$order->setStatus('created');

$workflow = $registry->get($order);

if ($workflow->can($order, 'to_pay')) {
    $workflow->apply($order, 'to_pay');
}

一些 Tips

transition 尽量避免多个 `from`

虽然 [symfony/workflow] 支持单个这个特性, 但使用也有对应的规则: 要应用 transition 时从 subject 获取到的 place 必须跟 transition 的 from 保持一致.

private function buildTransitionBlockerListForTransition($subject, Marking $marking, Transition $transition)
{
    foreach ($transition->getFroms() as $place) {
        if (!$marking->has($place)) {
            return new TransitionBlockerList([
                TransitionBlocker::createBlockedByMarking($marking),
            ]);
        }
    }

    if (null === $this->dispatcher) {
        return new TransitionBlockerList();
    }

    // 注意在这里触发了 guard 事件
    $event = $this->guardTransition($subject, $marking, $transition);

    if ($event->isBlocked()) {
        return $event->getTransitionBlockerList();
    }

    return new TransitionBlockerList();
}

避免在 guard 事件监听中做中断退出操作

这主要是因为 announce 事件导致的, 看一下源码:

private function announce($subject, Transition $initialTransition, Marking $marking): void
{
    ...

    foreach ($this->getEnabledTransitions($subject) as $transition) {
        $this->dispatcher->dispatch($event, sprintf('workflow.%s.announce.%s', $this->name, $transition->getName()));
    }
}

public function getEnabledTransitions($subject)
{
    $enabledTransitions = [];
    $marking = $this->getMarking($subject);

    // 在这里是将 apply 了 transition 后, 以 subject 当前的 place 作为 from, 获取所有是这个 from 的 transition
    // 在 buildTransitionBlockerListForTransition() 方法中, 会触发 guard 事件
    // 也就是如果定义了 a b c 三个 place, a->b 定义为 alpha, b->c 定义为 beta
    // 那么当 apply 了 alpha 之后, 会触发 beta 的 guard 事件
    foreach ($this->definition->getTransitions() as $transition) {
        $transitionBlockerList = $this->buildTransitionBlockerListForTransition($subject, $marking, $transition);
        if ($transitionBlockerList->isEmpty()) {
            $enabledTransitions[] = $transition;
        }
    }

    return $enabledTransitions;
}

结合乐观锁

直接上一个结合 eloquent 的例子:

public function setStatus($status, array $context)
{
    $result = $this
    ->newQuery()
    ->where([
        'id' => $this->attributes['id'],
        'status' => $this->attributes['status'],
    ])
    ->update([
        'status' => $status,
    ]);

    if (!$result) {
        throw new MarkingStateException(sprintf(
            'failed to set the "%s" status for model [%s] %s',
            $status,
            static::class,
            $this->attributes['id']
        ));
    }

    $this->attributes['status'] = $this->original['status'] = $status;
}

参考

laravel 接入 jaeger 分布式追踪系统

Mon, 05 Aug 2019 00:00:00 +0000

Jaeger 是一个兼容 opentracing 的分布式追踪系统, 摘抄一下阿里云栖里的文章来理解一下:

这种弹性、标准化的架构背后，原先运维与诊断的需求也变得越来越复杂。为了应对这种变化趋势，诞生一系列面向 DevOps 的诊断与分析系统，包括集中式日志系统（Logging），集中式度量系统（Metrics）和分布式追踪系统（Tracing）。

Logging，Metrics 和 Tracing 有各自专注的部分。

- Logging - 用于记录离散的事件。例如，应用程序的调试信息或错误信息。它是我们诊断问题的依据。
- Metrics - 用于记录可聚合的数据。例如，队列的当前深度可被定义为一个度量值，在元素入队或出队时被更新；HTTP 请求个数可被定义为一个计数器，新请求到来时进行累加。
- Tracing - 用于记录请求范围内的信息。例如，一次远程方法调用的执行过程和耗时。它是我们排查系统性能问题的利器。

在 opentracing 的数据模型中, Trace（调用链）通过归属于此调用链的 Span 来隐性的定义。一条 Trace（调用链）可以被认为是一个由多个 Span 组成的有向无环图（DAG图），Span 与 Span 的关系被命名为 References。

分布式追踪系统发展很快，种类繁多，但核心步骤一般有三个：代码埋点，数据存储、查询展示。

单个 Trace 中，span 间的因果关系


        [Span A]  ←←←(the root span)
            |
     +------+------+
     |             |
 [Span B]      [Span C] ←←←(Span C 是 Span A 的孩子节点, ChildOf)
     |             |
 [Span D]      +---+-------+
               |           |
           [Span E]    [Span F] >>> [Span G] >>> [Span H]
                                       ↑
                                       ↑
                                       ↑
                         (Span G 在 Span F 后被调用, FollowsFrom)

我简单地理解就是, 一次调用就会产生一条 trace, 并且本次调用既是一个 (root) span, 在这次调用中产生的其他调用会创建对应 span 并作关联.

例如: 客户端调用 A 系统的 A1 接口, A1 接口需要调用 B 系统的 B2 接口来获取数据, 那么就会产生一个 trace, 其中有三个 span. (此处存疑)

每个 span 中包含这些数据:

operation name 操作名称
start timestamp 起始时间
finish timestamp 结束时间
span tags span 标签
span log span 日志
spanContext span 上下文
reference span 间关系

其中 spanContext 包含这些内容:

任何一个 OpenTracing 的实现，都需要将当前调用链的状态（例如：trace 和 span 的 id），依赖一个独特的 Span 去跨进程边界传输
Baggage Items，Trace 的随行数据，是一个键值对集合，它存在于 trace 中，也需要跨进程边界传输

大部分似懂非懂, 干脆上手吧.

首先先本地部署一下 jaeger, 直接用 docker 即可, docker-compose 增加配置:

services:
    jaegertracing:
        image: jaegertracing/all-in-one
        ports:
            - 5775:5775/udp
            - 5778:5778
            - 14250:14250
            - 14268:14268
            - 6831:6831/udp
            - 6832:6832/udp
            - 16686:16686

jaegertracing/all-in-one 这个镜像提供了数据存储和 UI, 那么就是来搞定代码埋点. 需要埋点的是一个 laravel 项目, 项目中用到的 http client 是 guzzle.

首先修改 composer.json, 增加依赖 jukylin/jaeger-php

{
    "minimum-stability": "dev",
    "prefer-stable": true,
    "require": {
        "jukylin/jaeger-php": "dev-master"
    }
}

因为 span 中需要记录起止时间, 并且希望尽可能地记录到所有的调用 (主要是避免在框架 bootstrap 过程中发生异常时还没初始化好 jaeger trace), 所以处理的方式有两种:

直接在 bootstrap/app.php 中在创建好服务容器实例之后创建 jaeger trace 并注册到容器中
以服务提供者 (ServiceProvider) 的形式来创建并注册到容器中

为了不折腾, 就直接写成服务提供者吧. 一定要写在 register() 方法中, 在里面需要做一些事:

创建一个 Jaeger Trace 实例
创建一个全局 span, 代表本次调用
fpm 模式下使用 route.name 作为 span operation name, 匹配不到路由的则用 request.path_info. cli 模式下用 command.name
在框架 terminating 时, 调用 trace.flush(), 并且需要注册 register_shutdown_hander() 来实现异常退出时正常提交
在消息队列的 worker 中使用了信号监听来实现平滑退出和超时机制, 但会导致 register_shutdown_hander() 注册的 callback 失效, 所以需要每次消费一条消息就 flush 一次
注册一个经过改写的 guzzle client 到容器, 后续在项目中通过服务容器来获取 guzzle client

class JaegerServiceProvider extends ServiceProvider
{
    public function boot()
    {
    }

    /**
     * laravel 在 bootstrap 中, 会先注册所有的 provider, 再调用所有 provider 的 boot
     * 而在 provider 中, laravel 有 Event / Log / Routing 三个内置的 base provider
     * 在接入 jaeger 的逻辑中, 除了初始化 trace 和创建全局 span 以外, span 和 trace 的提交都是通过事件监听完成
     * 因此为了获取更加接近于请求实际的跟踪信息 (主要是请求时间) 以及避免其他无法预料的错误
     * 需要将 JaegerServiceProvider 在 app.php 中配置为第一个 provider, 并在 register 中进行初始化.
     *
     * @see https://github.com/mauri870/laravel-jaeger-demo/blob/master/app/Providers/AppServiceProvider.php
     */
    public function register()
    {
        $config = Config::getInstance();

        if ($sampler = config('services.jaeger.sampler')) {
            $config->setSampler($this->createSampler($sampler));
        }

        $config->setTransport(new TransportUdp('', 6000));

        $tracer = $config->initTrace(config('app.name'), config('services.jaeger.agent'));

        $tags = [
            'span.kind' => 'server',
            'type' => 'fpm',
        ];
        $operationName = '';

        if (app()->runningInConsole()) {
            $tags['type'] = 'cli';
            $this->registerCommandStartingListener();
        } else {
            $tags['http.url'] = $operationName = request()->getPathInfo();
        }

        $span = $tracer->startSpan($operationName, [
            'child_of' => $tracer->extract(TEXT_MAP, $_SERVER),
            'tags' => $tags,
        ]);
        $tracer->inject($span->spanContext, TEXT_MAP, $_SERVER);

        $this->app->instance('jaeger.config', $config);
        $this->app->instance('jaeger.tracer', $tracer);
        $this->app->instance('jaeger.span', $span);
        $this->app->instance('jaeger.flushed', false);

        $this->registerRequestHandledListener();
        $this->registerMessageLoggedListener();
        $this->registerTerminateHandler();
        $this->registerQueueJobProcessListener();
    }

    /**
     * 消息队列消费记录
     * 由于队列使用了异步信号监听, 会导致 register_shutdown_handler() 失效, 所以选择在执行完一个 job 之后 flush 一次
     */
    protected function registerQueueJobProcessListener()
    {
        $span = null;

        Event::listen(JobProcessing::class, function (JobProcessing $event) use (&$span) {
            $tracer = $this->app->get('jaeger.tracer');
            $spanName = sprintf('job.%s', $event->job->resolveName());
            $span = $tracer->startSpan($spanName, [
                'child_of' => $this->app->get('jaeger.span'),
                'tags' => [
                    'span.kind' => 'server',
                    'type' => 'cli',    // 这里暂时不考虑 sync 的情况
                    'job.name' => $event->job->getName(),
                    'job.id' => $event->job->getJobId(),
                ],
            ]);
            $tracer->inject($span->spanContext, TEXT_MAP, $_SERVER);
        });

        Event::listen(JobProcessed::class, function () use (&$span) {
            $span->finish();
            $span = null;
            $tracer = $this->app->get('jaeger.tracer');
//            $tracer->spanThrifts = [];
            $tracer->flush();
        });

        $failListener = function ($event) use (&$span) {
            $span->setTags([
                'error' => true,
            ]);
            $span->log([
                'exception' => $event->exception->getMessage(),
            ]);
            $span->finish();
            $span = null;
            $tracer = $this->app->get('jaeger.tracer');
            $tracer->spanThrifts = [];
            $tracer->flush();
        };

        Event::listen(JobFailed::class, $failListener);
        Event::listen(JobExceptionOccurred::class, $failListener);
    }

    /**
     * 当处于 cli 模式下运行时, 匹配到 command 之后将 command.name 作为 span name.
     */
    protected function registerCommandStartingListener()
    {
        Event::listen(CommandStarting::class, function (CommandStarting $event) {
            $this->app->get('jaeger.span')->overwriteOperationName($event->command);
            $this->app->get('jaeger.span')->setTags([
                'command.name' => $event->command,
            ]);
        });
    }

    /**
     * 注册请求相关事件, 如果命中路由, 则将路由名作为 spanName.
     */
    protected function registerRequestHandledListener()
    {
        Event::listen(RouteMatched::class, function (RouteMatched $event) {
            $this->app->get('jaeger.span')->overwriteOperationName('/' . ltrim($event->request->route()->uri(), '/'));
        });
        Event::listen(RequestHandled::class, function (RequestHandled $event) {
            $this->app->get('jaeger.span')->setTags([
                'http.status' => $event->response->getStatusCode(),
            ]);
        });
    }

    /**
     * 注册日志记录事件, 通过事件标记 span 失败及记录日志.
     */
    protected function registerMessageLoggedListener()
    {
        Event::listen(MessageLogged::class, function (MessageLogged $event) {
            if ('error' === $event->level) {
                $this->app->get('jaeger.span')->setTags(
                    [
                        'error' => true,
                    ]
                );
                $this->app->get('jaeger.span')->log((array) $event);
            }
        });
    }

    /**
     * 注册退出 callback.
     */
    protected function registerTerminateHandler()
    {
        app()->terminating(function () {
            $this->flushJaegerTracer();
            $this->app->instance('jaeger.flushed', true);
        });

        register_shutdown_function(function () {
            if (!$this->app->has('jaeger.flushed') || $this->app->get('jaeger.flushed')) {
                return;
            }

            $this->flushJaegerTracer();
        });
    }

    /**
     * @param $sampler
     *
     * @return ProbabilisticSampler
     */
    protected function createSampler($sampler)
    {
        switch ($sampler) {
            case 'probabilistic':
                return new ProbabilisticSampler();
        }
    }

    protected function flushJaegerTracer()
    {
        $this->app->get('jaeger.span')->finish();
        $this->app->get('jaeger.config')->flush();
    }
}

然后就是改写 guzzle client 了. 需要在通过 guzzle client 每次调用接口时, 创建一个 span, 并将 traceId 传递出去. 直接上代码:

namespace App\Bus\Jaeger;

use Jaeger\Span;
use GuzzleHttp\Client;
use OpenTracing\Reference;
use GuzzleHttp\RequestOptions;
use GuzzleHttp\Psr7\UriResolver;
use function GuzzleHttp\Psr7\uri_for;
use const OpenTracing\Formats\TEXT_MAP;
use Psr\Http\Message\ResponseInterface;
use GuzzleHttp\Exception\RequestException;

class GuzzleClient extends Client
{
    /**
     * @param string $method
     * @param string $uri
     * @param array  $options
     *
     * @return mixed|ResponseInterface
     */
    public function request($method, $uri = '', array $options = [])
    {
        $tracer = app()->get('jaeger.tracer');

        $spanName = $this->generateJaegerSpanName($uri, $options);

        $span = $tracer->startSpan($spanName, [
            'references' => [
                Reference::create(Reference::CHILD_OF, $tracer->extract(TEXT_MAP, $_SERVER)),
            ],
            'tags' => [
                'http.method' => $method,
                'http.url' => $spanName,
                'span.kind' => 'client',
            ],
        ]);

        $traceHeaders = [];
        $tracer->inject($span->spanContext, TEXT_MAP, $traceHeaders);

        $options[RequestOptions::HEADERS] = array_merge($options[RequestOptions::HEADERS] ?? [], $traceHeaders);
        $options[RequestOptions::SYNCHRONOUS] = true;

        return $this
            ->requestAsync($method, $uri, $options)
            ->then(
                function (ResponseInterface $response) use ($span) {
                    $this->finishSpanOnFulfilled($response, $span);

                    return $response;
                },
                function (RequestException $exception) use ($span, $options) {
                    $this->finishSpanOnFailed($exception, $span, $options);

                    throw $exception;
                }
            )
            ->wait();
    }

    private function finishSpanOnFulfilled(ResponseInterface $response, Span $span)
    {
        $span->setTags([
            'http.status_code' => $response->getStatusCode(),
        ]);
        $span->finish();
    }

    private function finishSpanOnFailed(RequestException $exception, Span $span, array $options)
    {
        $span->setTags([
            'error' => true,
            'http.status_code' => $exception->getCode(),
        ]);

        unset($options[RequestOptions::SYNCHRONOUS]);

        $span->log([
            'exception' => $exception->getMessage(),
            'request_options' => json_encode($options),
        ]);
        $span->finish();
    }

    /**
     * 将调用 api 的 host + path 作为 span name.
     *
     * @param $uri
     * @param array $options
     *
     * @return string
     */
    private function generateJaegerSpanName($uri, array $options)
    {
        $options = array_merge(
            [
                'base_uri' => $this->getConfig('base_uri'),
            ],
            $options
        );

        $uri = uri_for(null === $uri ? '' : $uri);

        if (!empty($options['base_uri'])) {
            $uri = UriResolver::resolve(uri_for($options['base_uri']), $uri);
        }

        return $uri->getHost() . $uri->getPath();
    }
}

搞定啦.

参考

laravel auth 的小知识点

Wed, 10 Jul 2019 00:00:00 +0000

部门的新项目用了 laravel 5.5 开发, 今天推到测试环境发现在模型的 boot() 静态方法中注册的事件监听不起作用. 代码示例:

public static function boot()
{
    parent::boot();
    if ($user = Auth::user()) {
        static::creating(function ($model) {
            $model->create_uid = Auth::user()->id;
        });
    }
}

还好是测试环境, 猜测是在这个地方读取不到 session, 导致拿不到用户登录态, 所以没注册到监听. 所以临时改为在监听里面判断登录态:

static::creating(function ($model) {
    if ($user = Auth::user()) {
        $model->create_uid = Auth::user()->id;
    }
});

本篇完… 当然是不可能的啦, 需要找出为什么在这里还没读取到 session. 那么需要定位两个问题:

都知道 laravel 的 session handler 是自己实现的, 需要确定在哪里进行了 session_start
模型创建实例, 应该是在 session_start 之前, 那在哪里创建的实例

首先看一下 laravel 的 session, 是通过 StartSession 这个中间件来开启 session

public function handle($request, Closure $next)
{
    $this->sessionHandled = true;
    
    // 前置先加载 session
    if ($this->sessionConfigured()) {
        $request->setLaravelSession(
            $session = $this->startSession($request)
        );

        $this->collectGarbage($session);
    }
    $response = $next($request);

    // 将 session_id 放到响应的 cookie 里 
    if ($this->sessionConfigured()) {
        $this->storeCurrentUrl($request, $session);

        $this->addCookieToResponse($response, $session);
    }
    return $response;
}

public function getSession(Request $request)
{
    // 通过 Illuminate\Session\SessionManager 获取 session driver
    return tap($this->manager->driver(), function ($session) use ($request) {
        // 注意在这里将 cookie 中的 session id 传到 driver 中
        $session->setId($request->cookies->get($session->getName()));
    });
}

protected function startSession(Request $request)
{
    return tap($this->getSession($request), function ($session) use ($request) {
        $session->setRequestOnHandler($request);

        // 获取了驱动并设置了 session_id 后, 在这里进行 session_start
        $session->start();
    });
}

然后再由具体的 driver 进行读取 session, 具体先不看. 到这里就拿到了 session, 如果 auth 使用的是 SessionGuard 的话, 那么就可以通过 Auth::user() 拿到登录用户了.

但是拿不到, 那就证明还没到这步. 部门的这个项目用到了 prettus/l5-repository 这个包.

我在控制器的构造方法中增加了一个依赖注入将一个我的 Repository 注入进去, 那么就可以确定, 拿控制器实例的时候, StartSession 这个中间件还没运行到.

看一下 route dispatcher.

protected function sendRequestThroughRouter($request)
{
    $this->app->instance('request', $request);

    Facade::clearResolvedInstance('request');

    $this->bootstrap();

    return (new Pipeline($this->app))
                ->send($request)
                ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
                ->then($this->dispatchToRouter());
}

protected function dispatchToRouter()
{
    return function ($request) {
        $this->app->instance('request', $request);

        return $this->router->dispatch($request);
    };
}

没错啦, 还是 pipeline, 那大概猜到了, 先创建了控制器实例, 然后放进管道作为第一个 stage. 具体再定位进去:

protected function runRouteWithinStack(Route $route, Request $request)
{
    $shouldSkipMiddleware = $this->container->bound('middleware.disable') &&
                            $this->container->make('middleware.disable') === true;

    $middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddleware($route);

    return (new Pipeline($this->container))
                    ->send($request)
                    ->through($middleware)
                    ->then(function ($request) use ($route) {
                        return $this->prepareResponse(
                            $request, $route->run()
                        );
                    });
}

在 Router 里面是另外一层管道, 把 Route::run() 放在第一个 stage 里面执行. 到 Route::run() 里面就是直接调用控制器的 action 了. 所以这个管道就是执行路由所配置的中间件了.

因为 laravel 支持在控制器里面再配置中间件, 所以到这里就猜测应该是在这里获取控制器中配置的中间件然后连同在路由中配置的中间件

看一下 Router::gatherRouteMiddleware()

public function gatherRouteMiddleware(Route $route)
{
    $middleware = collect($route->gatherMiddleware())->map(function ($name) {
        return (array) MiddlewareNameResolver::resolve($name, $this->middleware, $this->middlewareGroups);
    })->flatten();

    return $this->sortMiddleware($middleware);
}

再看 Route::gatherMiddleware(), 果不其然, 有调用 Route::controllerMiddleware(), 干脆一路追踪下去

public function gatherMiddleware()
{
    if (! is_null($this->computedMiddleware)) {
        return $this->computedMiddleware;
    }

    $this->computedMiddleware = [];

    return $this->computedMiddleware = array_unique(array_merge(
        $this->middleware(), $this->controllerMiddleware()  // 在这里获取控制器配置的中间件
    ), SORT_REGULAR);
}

public function controllerMiddleware()
{
    if (! $this->isControllerAction()) {
        return [];
    }

    return $this->controllerDispatcher()->getMiddleware(
        // 在这里去获取控制器实例
        $this->getController(), $this->getControllerMethod()
    );
}

public function getController()
{
    if (! $this->controller) {
        $class = $this->parseControllerCallback()[0];
        // 在这里获取到控制器的实例, 到这一步的时候, StartSession 这个中间件还没执行.
        // 准确地将, 整个中间件管道还没开始执行, 那么在这里获取 session 并取得登录用户, 是不可行的
        $this->controller = $this->container->make(ltrim($class, '\\'));
    }

    return $this->controller;
}

这样就算是把问题定位出来了, 那么就按照一开始的修改去解决这个问题就好了.

参考

暂无, 纯靠自己人肉 DEBUG

mysql 的 savepoint

Mon, 01 Jul 2019 00:00:00 +0000

之前搞 Yii 或者 TP 的项目, 要避免嵌套事务, 总是需要把事务开启的状态通过参数传递. 最近在写 laravel 的项目, 一不小心又写了嵌套的事务.

但 laravel 的处理挺有意思. 用到了 savepoint. 摘抄一下维基百科关于 savepoint 的介绍:

savepoint是在数据库事务处理中实现“子事务”（subtransaction），也称为嵌套事务的方法。
事务可以回滚到savepoint而不影响savepoint创建前的变化。不需要放弃整个事务。

直接在 mysql 里面试一下:

mysql> begin;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from demo where id = 2;
+----+-----------+-----+------+------+------+
| id | username  | age | a    | b    | c    |
+----+-----------+-----+------+------+------+
|  2 | holy shit |  11 |    2 |    6 |   10 |
+----+-----------+-----+------+------+------+
1 rows in set (0.01 sec)

然后执行三次 update, 并分别创建 savepoint

mysql> update demo set username = 'aaa' where id = 2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> savepoint trans_1;
Query OK, 0 rows affected (0.00 sec)

mysql> update demo set username = 'bbb' where id = 2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> savepoint trans_2;
Query OK, 0 rows affected (0.00 sec)

mysql> update demo set username = 'ccc' where id = 2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> savepoint trans_3;
Query OK, 0 rows affected (0.00 sec)

然后再执行一次更新

mysql> update demo set username = 'ddd' where id = 2;
Query OK, 1 row affected (0.01 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> select * from demo where id = 2;
+----+----------+-----+------+------+------+
| id | username | age | a    | b    | c    |
+----+----------+-----+------+------+------+
|  2 | ddd      |  11 |    2 |    6 |   10 |
+----+----------+-----+------+------+------+
1 row in set (0.01 sec)

回滚到 trans_3

mysql> rollback to trans_3;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from demo where id = 2;
+----+----------+-----+------+------+------+
| id | username | age | a    | b    | c    |
+----+----------+-----+------+------+------+
|  2 | ccc      |  11 |    2 |    6 |   10 |
+----+----------+-----+------+------+------+
1 row in set (0.00 sec)

然后再回滚到 trans_2, 再尝试回滚到 trans_3

mysql> rollback to trans_2;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from demo where id = 2;
+----+----------+-----+------+------+------+
| id | username | age | a    | b    | c    |
+----+----------+-----+------+------+------+
|  2 | bbb      |  11 |    2 |    6 |   10 |
+----+----------+-----+------+------+------+
1 row in set (0.00 sec)

mysql> rollback to trans_3;
ERROR 1305 (42000): SAVEPOINT trans_3 does not exist

mysql> rollback to trans_2;
Query OK, 0 rows affected (0.00 sec)

可见回滚到 trans_2 之后 trans_3 就被释放掉了, 但 trans_2 没有. 手动释放 trans_2, 再查查看

mysql> release savepoint trans_2;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from demo where id = 2;
+----+----------+-----+------+------+------+
| id | username | age | a    | b    | c    |
+----+----------+-----+------+------+------+
|  2 | bbb      |  11 |    2 |    6 |   10 |
+----+----------+-----+------+------+------+
1 row in set (0.01 sec)

mysql> release savepoint trans_2;
ERROR 1305 (42000): SAVEPOINT trans_2 does not exist

释放之后并不会回滚到 trans_1. 这时候直接 rollback 掉.

mysql> rollback;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from demo where id = 2;
+----+-----------+-----+------+------+------+
| id | username  | age | a    | b    | c    |
+----+-----------+-----+------+------+------+
|  2 | holy shit |  11 |    2 |    6 |   10 |
+----+-----------+-----+------+------+------+
1 row in set (0.00 sec)

完美, 所以总结一下 savepoint 的注意事项:

mysql innodb 支持
需要显式的 rollback 或 commit
rollback to 到某个 savepoint 会释放掉它之后的 savepoint
rollback to 到某个不存在的 savepoint 时会报错

猜想一下, 如果是自己在 php 中实现的话, 大概是这样的步骤:

开启事务时, 判断应该是 “主事务” 还是 “子事务”, 如果是前者则执行 start transcation, 后者则创建 savepoint
通过参数传递事务层级, 或是将事务层级保存到某个地方, 例如类属性
回滚时, 根据当前层级回滚, 如果是回滚到最后一层时, 则执行 rollback
回滚后到某个 savepoint 后, 应当将 savepoint 保存为当前等级. 如果下次回滚到的层级是在这次的层级之后, 退出或不执行操作

看一下 laravel 中的实现:

namespace Illuminate\Database\Concerns;

trait ManagesTransactions
{
    public function beginTransaction()
    {
        // 这里是先开启事务/创建 savepoint, 再递增 $transactions
        $this->createTransaction();
        $this->transactions++;
        $this->fireConnectionEvent('beganTransaction');
    }

    protected function createTransaction()
    {
        if ($this->transactions == 0) {
            try {
                $this->getPdo()->beginTransaction();
            } catch (Exception $e) {
                $this->handleBeginTransactionException($e);
            }
        } elseif ($this->transactions >= 1 && $this->queryGrammar->supportsSavepoints()) {
            $this->createSavepoint();
        }
    }
}

可以看到, 每次调用 beginTransaction() 都会递增当前层级用作开启事务时的层级标识. 如果已经开启了事务的话, 则调用 createSavepoint() 进行创建 savepoint.

protected function createSavepoint()
{
    $this->getPdo()->exec(
        $this->queryGrammar->compileSavepoint('trans'.($this->transactions + 1))    // 注意这里加了 1
    );
}

而在 rollback 这里是这么处理的:

public function rollBack($toLevel = null)
{
    // 取要回滚到的 savepoint, 默认取上一个 savepoint
    $toLevel = is_null($toLevel)
                ? $this->transactions - 1
                : $toLevel;

    // 如果手动传入的层级范围有问题, 不执行操作
    if ($toLevel < 0 || $toLevel >= $this->transactions) {
        return;
    }
    $this->performRollBack($toLevel);
    $this->transactions = $toLevel;
    $this->fireConnectionEvent('rollingBack');
}

实际的回滚操作, 因为前面创建 savepoint 的时候有 + 1, 所以这里也需要 + 1

protected function performRollBack($toLevel)
{
    if ($toLevel == 0) {
        $this->getPdo()->rollBack();
    } elseif ($this->queryGrammar->supportsSavepoints()) {
        $this->getPdo()->exec(
            $this->queryGrammar->compileSavepointRollBack('trans'.($toLevel + 1))
        );
    }
}

laravel 真是屌屌的~

参考

我的老房子

Mon, 17 Jun 2019 00:00:00 +0000

家里住了几十年, 我们姐弟三人出生的房子, 这两天已经拆了. 童年青春期, 回想起来真好.

就是没机会跟小孩子说小舅舅以前在这个房子里多皮了.

使用 xdebug profiler + qcachegrind 做性能分析

Thu, 06 Jun 2019 00:00:00 +0000

首先安装 xdebug, 无论是 OSX 上直接跑 fpm, 还是用虚拟机或 docker 都可以, 安装后, 配置 xdebug

[xdebug]
zend_extension=xdebug.so
xdebug.remote_enable=1
xdebug.remote_handler=dbgp
xdebug.remote_mode=req
xdebug.remote_connect_back=0
xdebug.remote_host=0.0.0.0
xdebug.remote_port=9001
xdebug.idekey=PHPSTORM
xdebug.remote_autostart=0
xdebug.profiler_enable=0
xdebug.profiler_enable_trigger=1
xdebug.profiler_enable_trigger_value=1111111
xdebug.profiler_output_dir=/path/to/profiling/folder

其中 remote_host 在 mac 版的 docker 中, 需要配置为 host.docker.internal 才能在容器中访问到宿主机上的 PHPSTORM 进行断点调试.

其中关于性能报告的几项配置:

profiler_enable 为 0 关闭自动生成性能报告
profiler_enable_trigger 为 1 开启触发生成性能报告
profiler_enable_trigger_value 触发性能报告的 “密钥”
profiler_output_dir 性能报告文件目录

为了不过多影响本地调试, 关闭自动生成性能报告, 改由触发生成. 触发方式为在 GET / POST / COOKIE 变量中传一个 XDEBUG_PROFILE=${TRIGGER_VALUE}.

触发性能分析

如果用 chrome 的话, 则可以安装 Xdebug Helper. 配置 trigger_value.

如果是用 postman 或是 insomnia, 则可以在 queryString 或是 requestBody, 甚至是 cookie 中传递.

查看分析报告

在 mac 上使用的工具是 qcachegrind. 安装方式:

$ brew install graphviz
$ brew install qcachegrind

其中可能是我使用的系统版本比较新, 只有通过终端启动 qcachegrind 才能正常查看调用图.

根据 fpm 跑在宿主机还是虚拟机, xdebug 生成的性能报告中文件目录就会不一样. 首先是 fpm 跑在宿主机的情况.

命令行打开执行

$ cd /path/to/profiling/folder
$ qcachegrind

然后打开已经生成的报告文件

然后就可以了. 其中主要看调用次数, 时间消耗 (目前好像没有 xhprof 有的内存使用报告), 这里摘抄一下 xhprof 的几项关键信息, 同样适用于 xdebug.

funciton name ： 函数名
calls: 调用次数
Incl. Wall Time (microsec)： 函数运行时间（包括子函数）
IWall%：函数运行时间（包括子函数）占比
Excl. Wall Time (microsec)：函数运行时间（不包括子函数）
EWall%：函数运行时间（不包括子函数）

我用 laravel 跑了一个简单的例子, 看这个图左边圈中部分, 有两项自身运行时间都超过 30% (Excl. Wall Time / Self). 右上圈中的是源文件中具体某一行的运行时间. 右下圈中的是执行次数.

个人习惯是打开性能报告后, 按照以下步骤定位性能问题:

按照运行时间排序, 如果可以从 Self 直接定位到具体问题就最好.
如果 Self 的时间不明显, 可以先看 controller 的运行时间, 如果占的百分比较大, 就可以通过 Source Code 中看其中每一行的运行时间
如果 controller 的运行时间占比较小, 则定位框架的启动过程及关闭过程中

如果是 php5.6 的项目, 还可以借助 xhprof 来查看内存使用情况.

如果 fpm 是跑在容器或是虚拟机中, 且站点目录跟宿主机不一致的话, 生成的报告就无法直接查看 Source Code, 那么可以配置目录映射 (用 phpstorm 的话肯定熟悉这个).

关于 qcachegrind 的安装和使用, 也可以参考下面的博文.